From ff9cf1f1f21186fd984e20e78ecce23e906a7f53 Mon Sep 17 00:00:00 2001 From: Jon Leech <4693344+oddhack@users.noreply.github.com> Date: Fri, 25 Feb 2022 05:00:42 -0800 Subject: Update for VulkanSC-Docs 1.0.9 (initial Vulkan SC public release) --- README.md | 46 +- include/vulkan/vk_platform.h | 84 + include/vulkan/vulkan_android.h | 25 + include/vulkan/vulkan_beta.h | 25 + include/vulkan/vulkan_directfb.h | 25 + include/vulkan/vulkan_fuchsia.h | 25 + include/vulkan/vulkan_ggp.h | 25 + include/vulkan/vulkan_ios.h | 25 + include/vulkan/vulkan_macos.h | 25 + include/vulkan/vulkan_metal.h | 25 + include/vulkan/vulkan_sc.h | 93 + include/vulkan/vulkan_sc_core.h | 7774 +++++++ include/vulkan/vulkan_sc_core.hpp | 7774 +++++++ include/vulkan/vulkan_screen.h | 25 + include/vulkan/vulkan_vi.h | 25 + include/vulkan/vulkan_wayland.h | 25 + include/vulkan/vulkan_win32.h | 25 + include/vulkan/vulkan_xcb.h | 25 + include/vulkan/vulkan_xlib.h | 25 + include/vulkan/vulkan_xlib_xrandr.h | 25 + json/vk.json | 5255 +++++ json/vkpcc.json | 60 + json/vulkan_json_data.hpp | 36108 +++++++++++++++++++++++++++++ json/vulkan_json_gen.c | 20787 +++++++++++++++++ json/vulkan_json_gen.h | 975 + json/vulkan_json_parser.hpp | 14346 ++++++++++++ registry/apiconventions.py | 11 + registry/cgenerator.py | 420 + registry/conventions.py | 358 + registry/generator.py | 1222 + registry/genvk.py | 985 + registry/reg.py | 1600 ++ registry/spec_tools/util.py | 58 + registry/validusage.json | 41218 ++++++++++++++++++++++++++++++++++ registry/vk.xml | 20057 +++++++++++++++++ registry/vkconventions.py | 280 + 36 files changed, 159860 insertions(+), 26 deletions(-) create mode 100644 include/vulkan/vk_platform.h create mode 100644 include/vulkan/vulkan_android.h create mode 100644 include/vulkan/vulkan_beta.h create mode 100644 include/vulkan/vulkan_directfb.h create mode 100644 include/vulkan/vulkan_fuchsia.h create mode 100644 include/vulkan/vulkan_ggp.h create mode 100644 include/vulkan/vulkan_ios.h create mode 100644 include/vulkan/vulkan_macos.h create mode 100644 include/vulkan/vulkan_metal.h create mode 100644 include/vulkan/vulkan_sc.h create mode 100644 include/vulkan/vulkan_sc_core.h create mode 100644 include/vulkan/vulkan_sc_core.hpp create mode 100644 include/vulkan/vulkan_screen.h create mode 100644 include/vulkan/vulkan_vi.h create mode 100644 include/vulkan/vulkan_wayland.h create mode 100644 include/vulkan/vulkan_win32.h create mode 100644 include/vulkan/vulkan_xcb.h create mode 100644 include/vulkan/vulkan_xlib.h create mode 100644 include/vulkan/vulkan_xlib_xrandr.h create mode 100644 json/vk.json create mode 100644 json/vkpcc.json create mode 100644 json/vulkan_json_data.hpp create mode 100644 json/vulkan_json_gen.c create mode 100644 json/vulkan_json_gen.h create mode 100644 json/vulkan_json_parser.hpp create mode 100644 registry/apiconventions.py create mode 100644 registry/cgenerator.py create mode 100644 registry/conventions.py create mode 100644 registry/generator.py create mode 100755 registry/genvk.py create mode 100644 registry/reg.py create mode 100644 registry/spec_tools/util.py create mode 100644 registry/validusage.json create mode 100644 registry/vk.xml create mode 100755 registry/vkconventions.py diff --git a/README.md b/README.md index 910875f..29d2b50 100644 --- a/README.md +++ b/README.md @@ -2,27 +2,13 @@ Vulkan header files and API registry -## Default branch changed to 'main' 2021-09-12 +The default branch of this repository is `main`, containing files for the Vulkan API. -As discussed in #222, the default branch of this repository is now 'main'. -This change should be largely transparent to repository users, since github -rewrites many references to the old 'master' branch to 'main'. However, if -you have a checked-out local clone, you may wish to take the following steps -as recommended by github: - -```sh -git branch -m master main -git fetch origin -git branch -u origin/main main -git remote set-head origin -a -``` - -## Vulkan SC Headers and JSON Files - -The `sc_main` branch of this repository contains generated headers and JSON -files for the Vulkan SC specification. +The `sc_main` branch contains files for the Vulkan SC API. The API XML and some of the scripts in this branch differ slightly from the -equivalent files in the `main` branch for Vulkan. +equivalent files in the `main` branch for Vulkan, and there are additional +generated `.json` files in the `json/` directory. + ## Repository Content @@ -33,7 +19,12 @@ If proposking changes to any file originating from a different repository, please propose such changes in that repository, rather than Vulkan-Headers. Files in this repository originate from: -### Specification repository (https://github.com/KhronosGroup/Vulkan-Docs) + +### Specification repository + +For the `main` branch, these files are derived from https://github.com/KhronosGroup/Vulkan-Docs + +For the `sc_main` branch, these files are derived from https://github.com/KhronosGroup/VulkanSC-Docs * registry/cgenerator.py * registry/conventions.py @@ -45,6 +36,8 @@ Files in this repository originate from: * registry/vk.xml * registry/vkconventions.py * All files under include/vulkan/ which are *not* listed explicitly as originating from another repository. +* For the `sc_main` branch, all `.json` files under `json/` + ### This repository (https://github.com/KhronosGroup/Vulkan-Headers) @@ -62,13 +55,14 @@ Files in this repository originate from: * include/vulkan/vk_layer.h * include/vulkan/vk_sdk_platform.h + ### Vulkan C++ Binding Repository (https://github.com/KhronosGroup/Vulkan-Hpp) As of the Vulkan-Docs 1.2.182 spec update, the Vulkan-Hpp headers have been split into multiple files. All of those files are now included in this repository. -*NOTE*: the `sc_main_ branch does not currently contain C++ headers, which +**Note**: the `sc_main_ branch does not currently contain C++ headers, which are not currently generated for Vulkan SC. * include/vulkan/vulkan.hpp @@ -78,14 +72,14 @@ are not currently generated for Vulkan SC. * include/vulkan/vulkan_raii.hpp * include/vulkan/vulkan_structs.hpp + ## Version Tagging Scheme -Updates to the `Vulkan-Headers` repository which correspond to a new Vulkan -specification release are tagged using the following format: -`v<`_`version`_`>` (e.g., `v1.3.202`). +Updates to `main` branch corresponding to a new Vulkan specification release +are tagged with the format: `v<`_`version`_`>` (e.g., `v1.3.202`). -Updates which correspond to a new Vulkan SC specification release are tagged -using the following format: `vksc<`_`version`_`>` (e.g., `vksc1.0.9`). +Updates to `sc_main` branch corresponding to a new Vulkan SC specification +release are tagged with the format: `vksc<`_`version`_`>` (e.g., `vksc1.0.9`). **Note**: Marked version releases have undergone thorough testing but do not imply the same quality level as SDK tags. SDK tags follow the diff --git a/include/vulkan/vk_platform.h b/include/vulkan/vk_platform.h new file mode 100644 index 0000000..5e1a95d --- /dev/null +++ b/include/vulkan/vk_platform.h @@ -0,0 +1,84 @@ +// +// File: vk_platform.h +// +/* +** Copyright 2014-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + + +#ifndef VK_PLATFORM_H_ +#define VK_PLATFORM_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif // __cplusplus + +/* +*************************************************************************************************** +* Platform-specific directives and type declarations +*************************************************************************************************** +*/ + +/* Platform-specific calling convention macros. + * + * Platforms should define these so that Vulkan clients call Vulkan commands + * with the same calling conventions that the Vulkan implementation expects. + * + * VKAPI_ATTR - Placed before the return type in function declarations. + * Useful for C++11 and GCC/Clang-style function attribute syntax. + * VKAPI_CALL - Placed after the return type in function declarations. + * Useful for MSVC-style calling convention syntax. + * VKAPI_PTR - Placed between the '(' and '*' in function pointer types. + * + * Function declaration: VKAPI_ATTR void VKAPI_CALL vkCommand(void); + * Function pointer type: typedef void (VKAPI_PTR *PFN_vkCommand)(void); + */ +#if defined(_WIN32) + // On Windows, Vulkan commands use the stdcall convention + #define VKAPI_ATTR + #define VKAPI_CALL __stdcall + #define VKAPI_PTR VKAPI_CALL +#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7 + #error "Vulkan is not supported for the 'armeabi' NDK ABI" +#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE) + // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat" + // calling convention, i.e. float parameters are passed in registers. This + // is true even if the rest of the application passes floats on the stack, + // as it does by default when compiling for the armeabi-v7a NDK ABI. + #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp"))) + #define VKAPI_CALL + #define VKAPI_PTR VKAPI_ATTR +#else + // On other platforms, use the default calling convention + #define VKAPI_ATTR + #define VKAPI_CALL + #define VKAPI_PTR +#endif + +#if !defined(VK_NO_STDDEF_H) + #include +#endif // !defined(VK_NO_STDDEF_H) + +#if !defined(VK_NO_STDINT_H) + #if defined(_MSC_VER) && (_MSC_VER < 1600) + typedef signed __int8 int8_t; + typedef unsigned __int8 uint8_t; + typedef signed __int16 int16_t; + typedef unsigned __int16 uint16_t; + typedef signed __int32 int32_t; + typedef unsigned __int32 uint32_t; + typedef signed __int64 int64_t; + typedef unsigned __int64 uint64_t; + #else + #include + #endif +#endif // !defined(VK_NO_STDINT_H) + +#ifdef __cplusplus +} // extern "C" +#endif // __cplusplus + +#endif diff --git a/include/vulkan/vulkan_android.h b/include/vulkan/vulkan_android.h new file mode 100644 index 0000000..493815f --- /dev/null +++ b/include/vulkan/vulkan_android.h @@ -0,0 +1,25 @@ +#ifndef VULKAN_ANDROID_H_ +#define VULKAN_ANDROID_H_ 1 + +/* +** Copyright 2015-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/vulkan/vulkan_beta.h b/include/vulkan/vulkan_beta.h new file mode 100644 index 0000000..2f52052 --- /dev/null +++ b/include/vulkan/vulkan_beta.h @@ -0,0 +1,25 @@ +#ifndef VULKAN_BETA_H_ +#define VULKAN_BETA_H_ 1 + +/* +** Copyright 2015-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/vulkan/vulkan_directfb.h b/include/vulkan/vulkan_directfb.h new file mode 100644 index 0000000..a4ce9b3 --- /dev/null +++ b/include/vulkan/vulkan_directfb.h @@ -0,0 +1,25 @@ +#ifndef VULKAN_DIRECTFB_H_ +#define VULKAN_DIRECTFB_H_ 1 + +/* +** Copyright 2015-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/vulkan/vulkan_fuchsia.h b/include/vulkan/vulkan_fuchsia.h new file mode 100644 index 0000000..6ff712c --- /dev/null +++ b/include/vulkan/vulkan_fuchsia.h @@ -0,0 +1,25 @@ +#ifndef VULKAN_FUCHSIA_H_ +#define VULKAN_FUCHSIA_H_ 1 + +/* +** Copyright 2015-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/vulkan/vulkan_ggp.h b/include/vulkan/vulkan_ggp.h new file mode 100644 index 0000000..47d70e9 --- /dev/null +++ b/include/vulkan/vulkan_ggp.h @@ -0,0 +1,25 @@ +#ifndef VULKAN_GGP_H_ +#define VULKAN_GGP_H_ 1 + +/* +** Copyright 2015-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/vulkan/vulkan_ios.h b/include/vulkan/vulkan_ios.h new file mode 100644 index 0000000..8f8ef09 --- /dev/null +++ b/include/vulkan/vulkan_ios.h @@ -0,0 +1,25 @@ +#ifndef VULKAN_IOS_H_ +#define VULKAN_IOS_H_ 1 + +/* +** Copyright 2015-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/vulkan/vulkan_macos.h b/include/vulkan/vulkan_macos.h new file mode 100644 index 0000000..e6b2040 --- /dev/null +++ b/include/vulkan/vulkan_macos.h @@ -0,0 +1,25 @@ +#ifndef VULKAN_MACOS_H_ +#define VULKAN_MACOS_H_ 1 + +/* +** Copyright 2015-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/vulkan/vulkan_metal.h b/include/vulkan/vulkan_metal.h new file mode 100644 index 0000000..ee9b989 --- /dev/null +++ b/include/vulkan/vulkan_metal.h @@ -0,0 +1,25 @@ +#ifndef VULKAN_METAL_H_ +#define VULKAN_METAL_H_ 1 + +/* +** Copyright 2015-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/vulkan/vulkan_sc.h b/include/vulkan/vulkan_sc.h new file mode 100644 index 0000000..3723e96 --- /dev/null +++ b/include/vulkan/vulkan_sc.h @@ -0,0 +1,93 @@ +#ifndef VULKAN_SC_H_ +#define VULKAN_SC_H_ 1 + +/* +** Copyright 2015-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +#include "vk_platform.h" +#include "vulkan_sc_core.h" + +#ifdef VK_USE_PLATFORM_ANDROID_KHR +#include "vulkan_android.h" +#endif + +#ifdef VK_USE_PLATFORM_FUCHSIA +#include +#include "vulkan_fuchsia.h" +#endif + +#ifdef VK_USE_PLATFORM_IOS_MVK +#include "vulkan_ios.h" +#endif + + +#ifdef VK_USE_PLATFORM_MACOS_MVK +#include "vulkan_macos.h" +#endif + +#ifdef VK_USE_PLATFORM_METAL_EXT +#include "vulkan_metal.h" +#endif + +#ifdef VK_USE_PLATFORM_VI_NN +#include "vulkan_vi.h" +#endif + + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR +#include +#include "vulkan_wayland.h" +#endif + + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#include +#include "vulkan_win32.h" +#endif + + +#ifdef VK_USE_PLATFORM_XCB_KHR +#include +#include "vulkan_xcb.h" +#endif + + +#ifdef VK_USE_PLATFORM_XLIB_KHR +#include +#include "vulkan_xlib.h" +#endif + + +#ifdef VK_USE_PLATFORM_DIRECTFB_EXT +#include +#include "vulkan_directfb.h" +#endif + + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT +#include +#include +#include "vulkan_xlib_xrandr.h" +#endif + + +#ifdef VK_USE_PLATFORM_GGP +#include +#include "vulkan_ggp.h" +#endif + + +#ifdef VK_USE_PLATFORM_SCREEN_QNX +#include +#include "vulkan_screen.h" +#endif + + +#ifdef VK_ENABLE_BETA_EXTENSIONS +#include "vulkan_beta.h" +#endif + +#endif // VULKAN_SC_H_ diff --git a/include/vulkan/vulkan_sc_core.h b/include/vulkan/vulkan_sc_core.h new file mode 100644 index 0000000..8e21555 --- /dev/null +++ b/include/vulkan/vulkan_sc_core.h @@ -0,0 +1,7774 @@ +#ifndef VULKAN_SC_CORE_H_ +#define VULKAN_SC_CORE_H_ 1 + +/* +** Copyright 2015-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define VK_VERSION_1_0 1 +#include "vk_platform.h" + +#define VK_DEFINE_HANDLE(object) typedef struct object##_T* (object); + + +#ifndef VK_USE_64_BIT_PTR_DEFINES + #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) + #define VK_USE_64_BIT_PTR_DEFINES 1 + #else + #define VK_USE_64_BIT_PTR_DEFINES 0 + #endif +#endif + + +#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE + #if (VK_USE_64_BIT_PTR_DEFINES==1) + #if (defined(__cplusplus) && (__cplusplus >= 201103L)) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201103L)) + #define VK_NULL_HANDLE nullptr + #else + #define VK_NULL_HANDLE ((void*)0) + #endif + #else + #define VK_NULL_HANDLE 0ULL + #endif +#endif +#ifndef VK_NULL_HANDLE + #define VK_NULL_HANDLE 0 +#endif + + +#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE + #if (VK_USE_64_BIT_PTR_DEFINES==1) + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *(object); + #else + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t (object); + #endif +#endif + +#define VK_MAKE_API_VERSION(variant, major, minor, patch) \ + ((((uint32_t)(variant)) << 29) | (((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch))) + +// Vulkan 1.0 version number +#define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0 + +// Version of this file +#define VK_HEADER_VERSION 9 + +// Vulkan SC variant number +#define VKSC_API_VARIANT 1 + +// Complete version of this file +#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, VK_HEADER_VERSION) + +#define VK_API_VERSION_VARIANT(version) ((uint32_t)(version) >> 29) +#define VK_API_VERSION_MAJOR(version) (((uint32_t)(version) >> 22) & 0x7FU) +#define VK_API_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3FFU) +#define VK_API_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU) +typedef uint32_t VkBool32; +typedef uint64_t VkDeviceAddress; +typedef uint64_t VkDeviceSize; +typedef uint32_t VkFlags; +typedef uint32_t VkSampleMask; +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) +VK_DEFINE_HANDLE(VkInstance) +VK_DEFINE_HANDLE(VkPhysicalDevice) +VK_DEFINE_HANDLE(VkDevice) +VK_DEFINE_HANDLE(VkQueue) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) +VK_DEFINE_HANDLE(VkCommandBuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) +#define VK_UUID_SIZE 16U +#define VK_ATTACHMENT_UNUSED (~0U) +#define VK_FALSE 0U +#define VK_LOD_CLAMP_NONE 1000.0F +#define VK_QUEUE_FAMILY_IGNORED (~0U) +#define VK_REMAINING_ARRAY_LAYERS (~0U) +#define VK_REMAINING_MIP_LEVELS (~0U) +#define VK_SUBPASS_EXTERNAL (~0U) +#define VK_TRUE 1U +#define VK_WHOLE_SIZE (~0ULL) +#define VK_MAX_MEMORY_TYPES 32U +#define VK_MAX_MEMORY_HEAPS 16U +#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256U +#define VK_MAX_EXTENSION_NAME_SIZE 256U +#define VK_MAX_DESCRIPTION_SIZE 256U + +typedef enum VkResult { + VK_SUCCESS = 0, + VK_NOT_READY = 1, + VK_TIMEOUT = 2, + VK_EVENT_SET = 3, + VK_EVENT_RESET = 4, + VK_INCOMPLETE = 5, + VK_ERROR_OUT_OF_HOST_MEMORY = -1, + VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, + VK_ERROR_INITIALIZATION_FAILED = -3, + VK_ERROR_DEVICE_LOST = -4, + VK_ERROR_MEMORY_MAP_FAILED = -5, + VK_ERROR_LAYER_NOT_PRESENT = -6, + VK_ERROR_EXTENSION_NOT_PRESENT = -7, + VK_ERROR_FEATURE_NOT_PRESENT = -8, + VK_ERROR_INCOMPATIBLE_DRIVER = -9, + VK_ERROR_TOO_MANY_OBJECTS = -10, + VK_ERROR_FORMAT_NOT_SUPPORTED = -11, + VK_ERROR_FRAGMENTED_POOL = -12, + VK_ERROR_UNKNOWN = -13, + VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000, + VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003, + VK_ERROR_FRAGMENTATION = -1000161000, + VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000, + VK_ERROR_VALIDATION_FAILED = -1000011001, + VK_ERROR_INVALID_PIPELINE_CACHE_DATA = -1000298000, + VK_ERROR_NO_PIPELINE_MATCH = -1000298001, + VK_ERROR_SURFACE_LOST_KHR = -1000000000, + VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, + VK_SUBOPTIMAL_KHR = 1000001003, + VK_ERROR_OUT_OF_DATE_KHR = -1000001004, + VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, + VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000, + VK_ERROR_NOT_PERMITTED_EXT = -1000174001, + VK_RESULT_MAX_ENUM = 0x7FFFFFFF +} VkResult; + +typedef enum VkStructureType { + VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, + VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, + VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, + VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, + VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, + VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, + VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, + VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, + VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, + VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, + VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, + VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001, + VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, + VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, + VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, + VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000, + VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, + VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, + VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, + VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, + VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, + VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, + VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 = 1000109000, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 = 1000109001, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 = 1000109002, + VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 = 1000109003, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004, + VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005, + VK_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000, + VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000, + VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000, + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001, + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002, + VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001, + VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO = 1000207002, + VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003, + VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004, + VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO = 1000244001, + VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002, + VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES = 1000298000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES = 1000298001, + VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO = 1000298002, + VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO = 1000298003, + VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_CONSUMPTION = 1000298004, + VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE = 1000298005, + VK_STRUCTURE_TYPE_FAULT_DATA = 1000298007, + VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO = 1000298008, + VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO = 1000298010, + VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, + VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, + VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009, + VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012, + VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, + VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, + VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = 1000066000, + VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, + VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, + VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, + VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000, + VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, + VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, + VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, + VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, + VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001, + VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, + VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, + VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, + VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001, + VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002, + VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003, + VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004, + VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005, + VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006, + VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR = 1000116007, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, + VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, + VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001, + VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004, + VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000, + VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001, + VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002, + VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003, + VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004, + VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000, + VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, + VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, + VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, + VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005, + VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT = 1000158006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000, + VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, + VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000, + VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR = 1000215000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = 1000225000, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = 1000225001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = 1000225002, + VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000226000, + VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR = 1000226001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR = 1000226002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR = 1000226003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000, + VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000, + VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = 1000276000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = 1000281001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001, + VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002, + VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR = 1000308000, + VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR = 1000314000, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR = 1000314001, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR = 1000314002, + VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR = 1000314003, + VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR = 1000314004, + VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR = 1000314005, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR = 1000314006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR = 1000314007, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008, + VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV = 1000314009, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT = 1000330000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT = 1000335000, + VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR = 1000337000, + VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR = 1000337001, + VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR = 1000337002, + VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR = 1000337003, + VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR = 1000337004, + VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR = 1000337005, + VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR = 1000337006, + VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR = 1000337007, + VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR = 1000337008, + VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR = 1000337009, + VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR = 1000337010, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000, + VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001, + VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT = 1000377000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT = 1000381000, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001, + VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT = 1000435000, + VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkStructureType; + +typedef enum VkImageLayout { + VK_IMAGE_LAYOUT_UNDEFINED = 0, + VK_IMAGE_LAYOUT_GENERAL = 1, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, + VK_IMAGE_LAYOUT_PREINITIALIZED = 8, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001, + VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002, + VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003, + VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, + VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, + VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003, + VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR = 1000314000, + VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR = 1000314001, + VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF +} VkImageLayout; + +typedef enum VkObjectType { + VK_OBJECT_TYPE_UNKNOWN = 0, + VK_OBJECT_TYPE_INSTANCE = 1, + VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2, + VK_OBJECT_TYPE_DEVICE = 3, + VK_OBJECT_TYPE_QUEUE = 4, + VK_OBJECT_TYPE_SEMAPHORE = 5, + VK_OBJECT_TYPE_COMMAND_BUFFER = 6, + VK_OBJECT_TYPE_FENCE = 7, + VK_OBJECT_TYPE_DEVICE_MEMORY = 8, + VK_OBJECT_TYPE_BUFFER = 9, + VK_OBJECT_TYPE_IMAGE = 10, + VK_OBJECT_TYPE_EVENT = 11, + VK_OBJECT_TYPE_QUERY_POOL = 12, + VK_OBJECT_TYPE_BUFFER_VIEW = 13, + VK_OBJECT_TYPE_IMAGE_VIEW = 14, + VK_OBJECT_TYPE_PIPELINE_CACHE = 16, + VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17, + VK_OBJECT_TYPE_RENDER_PASS = 18, + VK_OBJECT_TYPE_PIPELINE = 19, + VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20, + VK_OBJECT_TYPE_SAMPLER = 21, + VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22, + VK_OBJECT_TYPE_DESCRIPTOR_SET = 23, + VK_OBJECT_TYPE_FRAMEBUFFER = 24, + VK_OBJECT_TYPE_COMMAND_POOL = 25, + VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000, + VK_OBJECT_TYPE_SURFACE_KHR = 1000000000, + VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000, + VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000, + VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001, + VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000, + VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkObjectType; + +typedef enum VkPipelineCacheHeaderVersion { + VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, + VK_PIPELINE_CACHE_HEADER_VERSION_SAFETY_CRITICAL_ONE = 1000298001, + VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCacheHeaderVersion; + +typedef enum VkVendorId { + VK_VENDOR_ID_VIV = 0x10001, + VK_VENDOR_ID_VSI = 0x10002, + VK_VENDOR_ID_KAZAN = 0x10003, + VK_VENDOR_ID_CODEPLAY = 0x10004, + VK_VENDOR_ID_MESA = 0x10005, + VK_VENDOR_ID_POCL = 0x10006, + VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF +} VkVendorId; + +typedef enum VkSystemAllocationScope { + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, + VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, + VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, + VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, + VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF +} VkSystemAllocationScope; + +typedef enum VkInternalAllocationType { + VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, + VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkInternalAllocationType; + +typedef enum VkFormat { + VK_FORMAT_UNDEFINED = 0, + VK_FORMAT_R4G4_UNORM_PACK8 = 1, + VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, + VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, + VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, + VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, + VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, + VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, + VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, + VK_FORMAT_R8_UNORM = 9, + VK_FORMAT_R8_SNORM = 10, + VK_FORMAT_R8_USCALED = 11, + VK_FORMAT_R8_SSCALED = 12, + VK_FORMAT_R8_UINT = 13, + VK_FORMAT_R8_SINT = 14, + VK_FORMAT_R8_SRGB = 15, + VK_FORMAT_R8G8_UNORM = 16, + VK_FORMAT_R8G8_SNORM = 17, + VK_FORMAT_R8G8_USCALED = 18, + VK_FORMAT_R8G8_SSCALED = 19, + VK_FORMAT_R8G8_UINT = 20, + VK_FORMAT_R8G8_SINT = 21, + VK_FORMAT_R8G8_SRGB = 22, + VK_FORMAT_R8G8B8_UNORM = 23, + VK_FORMAT_R8G8B8_SNORM = 24, + VK_FORMAT_R8G8B8_USCALED = 25, + VK_FORMAT_R8G8B8_SSCALED = 26, + VK_FORMAT_R8G8B8_UINT = 27, + VK_FORMAT_R8G8B8_SINT = 28, + VK_FORMAT_R8G8B8_SRGB = 29, + VK_FORMAT_B8G8R8_UNORM = 30, + VK_FORMAT_B8G8R8_SNORM = 31, + VK_FORMAT_B8G8R8_USCALED = 32, + VK_FORMAT_B8G8R8_SSCALED = 33, + VK_FORMAT_B8G8R8_UINT = 34, + VK_FORMAT_B8G8R8_SINT = 35, + VK_FORMAT_B8G8R8_SRGB = 36, + VK_FORMAT_R8G8B8A8_UNORM = 37, + VK_FORMAT_R8G8B8A8_SNORM = 38, + VK_FORMAT_R8G8B8A8_USCALED = 39, + VK_FORMAT_R8G8B8A8_SSCALED = 40, + VK_FORMAT_R8G8B8A8_UINT = 41, + VK_FORMAT_R8G8B8A8_SINT = 42, + VK_FORMAT_R8G8B8A8_SRGB = 43, + VK_FORMAT_B8G8R8A8_UNORM = 44, + VK_FORMAT_B8G8R8A8_SNORM = 45, + VK_FORMAT_B8G8R8A8_USCALED = 46, + VK_FORMAT_B8G8R8A8_SSCALED = 47, + VK_FORMAT_B8G8R8A8_UINT = 48, + VK_FORMAT_B8G8R8A8_SINT = 49, + VK_FORMAT_B8G8R8A8_SRGB = 50, + VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, + VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, + VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, + VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, + VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, + VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, + VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, + VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, + VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, + VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, + VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, + VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, + VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, + VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, + VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, + VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, + VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, + VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, + VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, + VK_FORMAT_R16_UNORM = 70, + VK_FORMAT_R16_SNORM = 71, + VK_FORMAT_R16_USCALED = 72, + VK_FORMAT_R16_SSCALED = 73, + VK_FORMAT_R16_UINT = 74, + VK_FORMAT_R16_SINT = 75, + VK_FORMAT_R16_SFLOAT = 76, + VK_FORMAT_R16G16_UNORM = 77, + VK_FORMAT_R16G16_SNORM = 78, + VK_FORMAT_R16G16_USCALED = 79, + VK_FORMAT_R16G16_SSCALED = 80, + VK_FORMAT_R16G16_UINT = 81, + VK_FORMAT_R16G16_SINT = 82, + VK_FORMAT_R16G16_SFLOAT = 83, + VK_FORMAT_R16G16B16_UNORM = 84, + VK_FORMAT_R16G16B16_SNORM = 85, + VK_FORMAT_R16G16B16_USCALED = 86, + VK_FORMAT_R16G16B16_SSCALED = 87, + VK_FORMAT_R16G16B16_UINT = 88, + VK_FORMAT_R16G16B16_SINT = 89, + VK_FORMAT_R16G16B16_SFLOAT = 90, + VK_FORMAT_R16G16B16A16_UNORM = 91, + VK_FORMAT_R16G16B16A16_SNORM = 92, + VK_FORMAT_R16G16B16A16_USCALED = 93, + VK_FORMAT_R16G16B16A16_SSCALED = 94, + VK_FORMAT_R16G16B16A16_UINT = 95, + VK_FORMAT_R16G16B16A16_SINT = 96, + VK_FORMAT_R16G16B16A16_SFLOAT = 97, + VK_FORMAT_R32_UINT = 98, + VK_FORMAT_R32_SINT = 99, + VK_FORMAT_R32_SFLOAT = 100, + VK_FORMAT_R32G32_UINT = 101, + VK_FORMAT_R32G32_SINT = 102, + VK_FORMAT_R32G32_SFLOAT = 103, + VK_FORMAT_R32G32B32_UINT = 104, + VK_FORMAT_R32G32B32_SINT = 105, + VK_FORMAT_R32G32B32_SFLOAT = 106, + VK_FORMAT_R32G32B32A32_UINT = 107, + VK_FORMAT_R32G32B32A32_SINT = 108, + VK_FORMAT_R32G32B32A32_SFLOAT = 109, + VK_FORMAT_R64_UINT = 110, + VK_FORMAT_R64_SINT = 111, + VK_FORMAT_R64_SFLOAT = 112, + VK_FORMAT_R64G64_UINT = 113, + VK_FORMAT_R64G64_SINT = 114, + VK_FORMAT_R64G64_SFLOAT = 115, + VK_FORMAT_R64G64B64_UINT = 116, + VK_FORMAT_R64G64B64_SINT = 117, + VK_FORMAT_R64G64B64_SFLOAT = 118, + VK_FORMAT_R64G64B64A64_UINT = 119, + VK_FORMAT_R64G64B64A64_SINT = 120, + VK_FORMAT_R64G64B64A64_SFLOAT = 121, + VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, + VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, + VK_FORMAT_D16_UNORM = 124, + VK_FORMAT_X8_D24_UNORM_PACK32 = 125, + VK_FORMAT_D32_SFLOAT = 126, + VK_FORMAT_S8_UINT = 127, + VK_FORMAT_D16_UNORM_S8_UINT = 128, + VK_FORMAT_D24_UNORM_S8_UINT = 129, + VK_FORMAT_D32_SFLOAT_S8_UINT = 130, + VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, + VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, + VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, + VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, + VK_FORMAT_BC2_UNORM_BLOCK = 135, + VK_FORMAT_BC2_SRGB_BLOCK = 136, + VK_FORMAT_BC3_UNORM_BLOCK = 137, + VK_FORMAT_BC3_SRGB_BLOCK = 138, + VK_FORMAT_BC4_UNORM_BLOCK = 139, + VK_FORMAT_BC4_SNORM_BLOCK = 140, + VK_FORMAT_BC5_UNORM_BLOCK = 141, + VK_FORMAT_BC5_SNORM_BLOCK = 142, + VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, + VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, + VK_FORMAT_BC7_UNORM_BLOCK = 145, + VK_FORMAT_BC7_SRGB_BLOCK = 146, + VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, + VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, + VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, + VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, + VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, + VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, + VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, + VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, + VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, + VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, + VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, + VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, + VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, + VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, + VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, + VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, + VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, + VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, + VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, + VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, + VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, + VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, + VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, + VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, + VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, + VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, + VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, + VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, + VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, + VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, + VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, + VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, + VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, + VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, + VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, + VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, + VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, + VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, + VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000, + VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001, + VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002, + VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003, + VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004, + VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005, + VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006, + VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007, + VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008, + VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009, + VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010, + VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016, + VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017, + VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018, + VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019, + VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020, + VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026, + VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027, + VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028, + VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029, + VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030, + VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031, + VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032, + VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033, + VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = 1000066000, + VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = 1000066001, + VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = 1000066002, + VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = 1000066003, + VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = 1000066004, + VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = 1000066005, + VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = 1000066006, + VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = 1000066007, + VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = 1000066008, + VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = 1000066009, + VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = 1000066010, + VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = 1000066011, + VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = 1000066012, + VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = 1000066013, + VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT = 1000330000, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT = 1000330001, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT = 1000330002, + VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT = 1000330003, + VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT = 1000340000, + VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT = 1000340001, + VK_FORMAT_MAX_ENUM = 0x7FFFFFFF +} VkFormat; + +typedef enum VkImageTiling { + VK_IMAGE_TILING_OPTIMAL = 0, + VK_IMAGE_TILING_LINEAR = 1, + VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000, + VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF +} VkImageTiling; + +typedef enum VkImageType { + VK_IMAGE_TYPE_1D = 0, + VK_IMAGE_TYPE_2D = 1, + VK_IMAGE_TYPE_3D = 2, + VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageType; + +typedef enum VkPhysicalDeviceType { + VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, + VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, + VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, + VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, + VK_PHYSICAL_DEVICE_TYPE_CPU = 4, + VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkPhysicalDeviceType; + +typedef enum VkQueryType { + VK_QUERY_TYPE_OCCLUSION = 0, + VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, + VK_QUERY_TYPE_TIMESTAMP = 2, + VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000, + VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkQueryType; + +typedef enum VkSharingMode { + VK_SHARING_MODE_EXCLUSIVE = 0, + VK_SHARING_MODE_CONCURRENT = 1, + VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSharingMode; + +typedef enum VkComponentSwizzle { + VK_COMPONENT_SWIZZLE_IDENTITY = 0, + VK_COMPONENT_SWIZZLE_ZERO = 1, + VK_COMPONENT_SWIZZLE_ONE = 2, + VK_COMPONENT_SWIZZLE_R = 3, + VK_COMPONENT_SWIZZLE_G = 4, + VK_COMPONENT_SWIZZLE_B = 5, + VK_COMPONENT_SWIZZLE_A = 6, + VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF +} VkComponentSwizzle; + +typedef enum VkImageViewType { + VK_IMAGE_VIEW_TYPE_1D = 0, + VK_IMAGE_VIEW_TYPE_2D = 1, + VK_IMAGE_VIEW_TYPE_3D = 2, + VK_IMAGE_VIEW_TYPE_CUBE = 3, + VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, + VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, + VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, + VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageViewType; + +typedef enum VkBlendFactor { + VK_BLEND_FACTOR_ZERO = 0, + VK_BLEND_FACTOR_ONE = 1, + VK_BLEND_FACTOR_SRC_COLOR = 2, + VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, + VK_BLEND_FACTOR_DST_COLOR = 4, + VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, + VK_BLEND_FACTOR_SRC_ALPHA = 6, + VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, + VK_BLEND_FACTOR_DST_ALPHA = 8, + VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, + VK_BLEND_FACTOR_CONSTANT_COLOR = 10, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, + VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, + VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, + VK_BLEND_FACTOR_SRC1_COLOR = 15, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, + VK_BLEND_FACTOR_SRC1_ALPHA = 17, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, + VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF +} VkBlendFactor; + +typedef enum VkBlendOp { + VK_BLEND_OP_ADD = 0, + VK_BLEND_OP_SUBTRACT = 1, + VK_BLEND_OP_REVERSE_SUBTRACT = 2, + VK_BLEND_OP_MIN = 3, + VK_BLEND_OP_MAX = 4, + VK_BLEND_OP_ZERO_EXT = 1000148000, + VK_BLEND_OP_SRC_EXT = 1000148001, + VK_BLEND_OP_DST_EXT = 1000148002, + VK_BLEND_OP_SRC_OVER_EXT = 1000148003, + VK_BLEND_OP_DST_OVER_EXT = 1000148004, + VK_BLEND_OP_SRC_IN_EXT = 1000148005, + VK_BLEND_OP_DST_IN_EXT = 1000148006, + VK_BLEND_OP_SRC_OUT_EXT = 1000148007, + VK_BLEND_OP_DST_OUT_EXT = 1000148008, + VK_BLEND_OP_SRC_ATOP_EXT = 1000148009, + VK_BLEND_OP_DST_ATOP_EXT = 1000148010, + VK_BLEND_OP_XOR_EXT = 1000148011, + VK_BLEND_OP_MULTIPLY_EXT = 1000148012, + VK_BLEND_OP_SCREEN_EXT = 1000148013, + VK_BLEND_OP_OVERLAY_EXT = 1000148014, + VK_BLEND_OP_DARKEN_EXT = 1000148015, + VK_BLEND_OP_LIGHTEN_EXT = 1000148016, + VK_BLEND_OP_COLORDODGE_EXT = 1000148017, + VK_BLEND_OP_COLORBURN_EXT = 1000148018, + VK_BLEND_OP_HARDLIGHT_EXT = 1000148019, + VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020, + VK_BLEND_OP_DIFFERENCE_EXT = 1000148021, + VK_BLEND_OP_EXCLUSION_EXT = 1000148022, + VK_BLEND_OP_INVERT_EXT = 1000148023, + VK_BLEND_OP_INVERT_RGB_EXT = 1000148024, + VK_BLEND_OP_LINEARDODGE_EXT = 1000148025, + VK_BLEND_OP_LINEARBURN_EXT = 1000148026, + VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027, + VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028, + VK_BLEND_OP_PINLIGHT_EXT = 1000148029, + VK_BLEND_OP_HARDMIX_EXT = 1000148030, + VK_BLEND_OP_HSL_HUE_EXT = 1000148031, + VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032, + VK_BLEND_OP_HSL_COLOR_EXT = 1000148033, + VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034, + VK_BLEND_OP_PLUS_EXT = 1000148035, + VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036, + VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037, + VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038, + VK_BLEND_OP_MINUS_EXT = 1000148039, + VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040, + VK_BLEND_OP_CONTRAST_EXT = 1000148041, + VK_BLEND_OP_INVERT_OVG_EXT = 1000148042, + VK_BLEND_OP_RED_EXT = 1000148043, + VK_BLEND_OP_GREEN_EXT = 1000148044, + VK_BLEND_OP_BLUE_EXT = 1000148045, + VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF +} VkBlendOp; + +typedef enum VkCompareOp { + VK_COMPARE_OP_NEVER = 0, + VK_COMPARE_OP_LESS = 1, + VK_COMPARE_OP_EQUAL = 2, + VK_COMPARE_OP_LESS_OR_EQUAL = 3, + VK_COMPARE_OP_GREATER = 4, + VK_COMPARE_OP_NOT_EQUAL = 5, + VK_COMPARE_OP_GREATER_OR_EQUAL = 6, + VK_COMPARE_OP_ALWAYS = 7, + VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF +} VkCompareOp; + +typedef enum VkDynamicState { + VK_DYNAMIC_STATE_VIEWPORT = 0, + VK_DYNAMIC_STATE_SCISSOR = 1, + VK_DYNAMIC_STATE_LINE_WIDTH = 2, + VK_DYNAMIC_STATE_DEPTH_BIAS = 3, + VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, + VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, + VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, + VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, + VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, + VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, + VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000, + VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000, + VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000, + VK_DYNAMIC_STATE_CULL_MODE_EXT = 1000267000, + VK_DYNAMIC_STATE_FRONT_FACE_EXT = 1000267001, + VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = 1000267002, + VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT = 1000267003, + VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT = 1000267004, + VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT = 1000267005, + VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT = 1000267006, + VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT = 1000267007, + VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT = 1000267008, + VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT = 1000267009, + VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT = 1000267010, + VK_DYNAMIC_STATE_STENCIL_OP_EXT = 1000267011, + VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000, + VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000, + VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT = 1000377001, + VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT = 1000377002, + VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003, + VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT = 1000377004, + VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000, + VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF +} VkDynamicState; + +typedef enum VkFrontFace { + VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, + VK_FRONT_FACE_CLOCKWISE = 1, + VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF +} VkFrontFace; + +typedef enum VkVertexInputRate { + VK_VERTEX_INPUT_RATE_VERTEX = 0, + VK_VERTEX_INPUT_RATE_INSTANCE = 1, + VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF +} VkVertexInputRate; + +typedef enum VkPrimitiveTopology { + VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, + VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, + VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF +} VkPrimitiveTopology; + +typedef enum VkPolygonMode { + VK_POLYGON_MODE_FILL = 0, + VK_POLYGON_MODE_LINE = 1, + VK_POLYGON_MODE_POINT = 2, + VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF +} VkPolygonMode; + +typedef enum VkStencilOp { + VK_STENCIL_OP_KEEP = 0, + VK_STENCIL_OP_ZERO = 1, + VK_STENCIL_OP_REPLACE = 2, + VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, + VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, + VK_STENCIL_OP_INVERT = 5, + VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, + VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, + VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF +} VkStencilOp; + +typedef enum VkLogicOp { + VK_LOGIC_OP_CLEAR = 0, + VK_LOGIC_OP_AND = 1, + VK_LOGIC_OP_AND_REVERSE = 2, + VK_LOGIC_OP_COPY = 3, + VK_LOGIC_OP_AND_INVERTED = 4, + VK_LOGIC_OP_NO_OP = 5, + VK_LOGIC_OP_XOR = 6, + VK_LOGIC_OP_OR = 7, + VK_LOGIC_OP_NOR = 8, + VK_LOGIC_OP_EQUIVALENT = 9, + VK_LOGIC_OP_INVERT = 10, + VK_LOGIC_OP_OR_REVERSE = 11, + VK_LOGIC_OP_COPY_INVERTED = 12, + VK_LOGIC_OP_OR_INVERTED = 13, + VK_LOGIC_OP_NAND = 14, + VK_LOGIC_OP_SET = 15, + VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF +} VkLogicOp; + +typedef enum VkBorderColor { + VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, + VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, + VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, + VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, + VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, + VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, + VK_BORDER_COLOR_FLOAT_CUSTOM_EXT = 1000287003, + VK_BORDER_COLOR_INT_CUSTOM_EXT = 1000287004, + VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF +} VkBorderColor; + +typedef enum VkFilter { + VK_FILTER_NEAREST = 0, + VK_FILTER_LINEAR = 1, + VK_FILTER_CUBIC_IMG = 1000015000, + VK_FILTER_CUBIC_EXT = VK_FILTER_CUBIC_IMG, + VK_FILTER_MAX_ENUM = 0x7FFFFFFF +} VkFilter; + +typedef enum VkSamplerAddressMode { + VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, + VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, + VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, + VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerAddressMode; + +typedef enum VkSamplerMipmapMode { + VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, + VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, + VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerMipmapMode; + +typedef enum VkDescriptorType { + VK_DESCRIPTOR_TYPE_SAMPLER = 0, + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, + VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, + VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, + VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, + VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, + VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, + VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorType; + +typedef enum VkAttachmentLoadOp { + VK_ATTACHMENT_LOAD_OP_LOAD = 0, + VK_ATTACHMENT_LOAD_OP_CLEAR = 1, + VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, + VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentLoadOp; + +typedef enum VkAttachmentStoreOp { + VK_ATTACHMENT_STORE_OP_STORE = 0, + VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, + VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentStoreOp; + +typedef enum VkPipelineBindPoint { + VK_PIPELINE_BIND_POINT_GRAPHICS = 0, + VK_PIPELINE_BIND_POINT_COMPUTE = 1, + VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF +} VkPipelineBindPoint; + +typedef enum VkCommandBufferLevel { + VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, + VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, + VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferLevel; + +typedef enum VkIndexType { + VK_INDEX_TYPE_UINT16 = 0, + VK_INDEX_TYPE_UINT32 = 1, + VK_INDEX_TYPE_UINT8_EXT = 1000265000, + VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkIndexType; + +typedef enum VkSubpassContents { + VK_SUBPASS_CONTENTS_INLINE = 0, + VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, + VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF +} VkSubpassContents; + +// Flag bits for VkAccessFlagBits +typedef VkFlags VkAccessFlagBits; +#define VK_ACCESS_INDIRECT_COMMAND_READ_BIT 0x00000001U +#define VK_ACCESS_INDEX_READ_BIT 0x00000002U +#define VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT 0x00000004U +#define VK_ACCESS_UNIFORM_READ_BIT 0x00000008U +#define VK_ACCESS_INPUT_ATTACHMENT_READ_BIT 0x00000010U +#define VK_ACCESS_SHADER_READ_BIT 0x00000020U +#define VK_ACCESS_SHADER_WRITE_BIT 0x00000040U +#define VK_ACCESS_COLOR_ATTACHMENT_READ_BIT 0x00000080U +#define VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT 0x00000100U +#define VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT 0x00000200U +#define VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT 0x00000400U +#define VK_ACCESS_TRANSFER_READ_BIT 0x00000800U +#define VK_ACCESS_TRANSFER_WRITE_BIT 0x00001000U +#define VK_ACCESS_HOST_READ_BIT 0x00002000U +#define VK_ACCESS_HOST_WRITE_BIT 0x00004000U +#define VK_ACCESS_MEMORY_READ_BIT 0x00008000U +#define VK_ACCESS_MEMORY_WRITE_BIT 0x00010000U +#define VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT 0x00080000U +#define VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR 0x00800000U +#define VK_ACCESS_NONE_KHR 0U + +typedef VkFlags VkAccessFlags; + +// Flag bits for VkImageAspectFlagBits +typedef VkFlags VkImageAspectFlagBits; +#define VK_IMAGE_ASPECT_COLOR_BIT 0x00000001U +#define VK_IMAGE_ASPECT_DEPTH_BIT 0x00000002U +#define VK_IMAGE_ASPECT_STENCIL_BIT 0x00000004U +#define VK_IMAGE_ASPECT_METADATA_BIT 0x00000008U +#define VK_IMAGE_ASPECT_PLANE_0_BIT 0x00000010U +#define VK_IMAGE_ASPECT_PLANE_1_BIT 0x00000020U +#define VK_IMAGE_ASPECT_PLANE_2_BIT 0x00000040U +#define VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT 0x00000080U +#define VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT 0x00000100U +#define VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT 0x00000200U +#define VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT 0x00000400U + +typedef VkFlags VkImageAspectFlags; + +// Flag bits for VkFormatFeatureFlagBits +typedef VkFlags VkFormatFeatureFlagBits; +#define VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT 0x00000001U +#define VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT 0x00000002U +#define VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT 0x00000004U +#define VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT 0x00000008U +#define VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT 0x00000010U +#define VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT 0x00000020U +#define VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT 0x00000040U +#define VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT 0x00000080U +#define VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT 0x00000100U +#define VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT 0x00000200U +#define VK_FORMAT_FEATURE_BLIT_SRC_BIT 0x00000400U +#define VK_FORMAT_FEATURE_BLIT_DST_BIT 0x00000800U +#define VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT 0x00001000U +#define VK_FORMAT_FEATURE_TRANSFER_SRC_BIT 0x00004000U +#define VK_FORMAT_FEATURE_TRANSFER_DST_BIT 0x00008000U +#define VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT 0x00020000U +#define VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT 0x00040000U +#define VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT 0x00080000U +#define VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT 0x00100000U +#define VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT 0x00200000U +#define VK_FORMAT_FEATURE_DISJOINT_BIT 0x00400000U +#define VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT 0x00800000U +#define VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT 0x00010000U +#define VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG 0x00002000U +#define VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR 0x40000000U +#define VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG + +typedef VkFlags VkFormatFeatureFlags; + +// Flag bits for VkImageCreateFlagBits +typedef VkFlags VkImageCreateFlagBits; +#define VK_IMAGE_CREATE_SPARSE_BINDING_BIT 0x00000001U +#define VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT 0x00000002U +#define VK_IMAGE_CREATE_SPARSE_ALIASED_BIT 0x00000004U +#define VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT 0x00000008U +#define VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT 0x00000010U +#define VK_IMAGE_CREATE_ALIAS_BIT 0x00000400U +#define VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT 0x00000040U +#define VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT 0x00000020U +#define VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT 0x00000080U +#define VK_IMAGE_CREATE_EXTENDED_USAGE_BIT 0x00000100U +#define VK_IMAGE_CREATE_PROTECTED_BIT 0x00000800U +#define VK_IMAGE_CREATE_DISJOINT_BIT 0x00000200U +#define VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT 0x00001000U + +typedef VkFlags VkImageCreateFlags; + +// Flag bits for VkSampleCountFlagBits +typedef VkFlags VkSampleCountFlagBits; +#define VK_SAMPLE_COUNT_1_BIT 0x00000001U +#define VK_SAMPLE_COUNT_2_BIT 0x00000002U +#define VK_SAMPLE_COUNT_4_BIT 0x00000004U +#define VK_SAMPLE_COUNT_8_BIT 0x00000008U +#define VK_SAMPLE_COUNT_16_BIT 0x00000010U +#define VK_SAMPLE_COUNT_32_BIT 0x00000020U +#define VK_SAMPLE_COUNT_64_BIT 0x00000040U + +typedef VkFlags VkSampleCountFlags; + +// Flag bits for VkImageUsageFlagBits +typedef VkFlags VkImageUsageFlagBits; +#define VK_IMAGE_USAGE_TRANSFER_SRC_BIT 0x00000001U +#define VK_IMAGE_USAGE_TRANSFER_DST_BIT 0x00000002U +#define VK_IMAGE_USAGE_SAMPLED_BIT 0x00000004U +#define VK_IMAGE_USAGE_STORAGE_BIT 0x00000008U +#define VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT 0x00000010U +#define VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT 0x00000020U +#define VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT 0x00000040U +#define VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT 0x00000080U +#define VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR 0x00000100U + +typedef VkFlags VkImageUsageFlags; +typedef VkFlags VkInstanceCreateFlags; + +// Flag bits for VkMemoryHeapFlagBits +typedef VkFlags VkMemoryHeapFlagBits; +#define VK_MEMORY_HEAP_DEVICE_LOCAL_BIT 0x00000001U +#define VK_MEMORY_HEAP_MULTI_INSTANCE_BIT 0x00000002U +#define VK_MEMORY_HEAP_SEU_SAFE_BIT 0x00000004U + +typedef VkFlags VkMemoryHeapFlags; + +// Flag bits for VkMemoryPropertyFlagBits +typedef VkFlags VkMemoryPropertyFlagBits; +#define VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT 0x00000001U +#define VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT 0x00000002U +#define VK_MEMORY_PROPERTY_HOST_COHERENT_BIT 0x00000004U +#define VK_MEMORY_PROPERTY_HOST_CACHED_BIT 0x00000008U +#define VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT 0x00000010U +#define VK_MEMORY_PROPERTY_PROTECTED_BIT 0x00000020U + +typedef VkFlags VkMemoryPropertyFlags; + +// Flag bits for VkQueueFlagBits +typedef VkFlags VkQueueFlagBits; +#define VK_QUEUE_GRAPHICS_BIT 0x00000001U +#define VK_QUEUE_COMPUTE_BIT 0x00000002U +#define VK_QUEUE_TRANSFER_BIT 0x00000004U +#define VK_QUEUE_PROTECTED_BIT 0x00000010U + +typedef VkFlags VkQueueFlags; +typedef VkFlags VkDeviceCreateFlags; + +// Flag bits for VkDeviceQueueCreateFlagBits +typedef VkFlags VkDeviceQueueCreateFlagBits; +#define VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT 0x00000001U + +typedef VkFlags VkDeviceQueueCreateFlags; + +// Flag bits for VkPipelineStageFlagBits +typedef VkFlags VkPipelineStageFlagBits; +#define VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT 0x00000001U +#define VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT 0x00000002U +#define VK_PIPELINE_STAGE_VERTEX_INPUT_BIT 0x00000004U +#define VK_PIPELINE_STAGE_VERTEX_SHADER_BIT 0x00000008U +#define VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT 0x00000010U +#define VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT 0x00000020U +#define VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT 0x00000040U +#define VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT 0x00000080U +#define VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT 0x00000100U +#define VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT 0x00000200U +#define VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT 0x00000400U +#define VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT 0x00000800U +#define VK_PIPELINE_STAGE_TRANSFER_BIT 0x00001000U +#define VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT 0x00002000U +#define VK_PIPELINE_STAGE_HOST_BIT 0x00004000U +#define VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT 0x00008000U +#define VK_PIPELINE_STAGE_ALL_COMMANDS_BIT 0x00010000U +#define VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR 0x00400000U +#define VK_PIPELINE_STAGE_NONE_KHR 0U + +typedef VkFlags VkPipelineStageFlags; +typedef VkFlags VkMemoryMapFlags; + +// Flag bits for VkFenceCreateFlagBits +typedef VkFlags VkFenceCreateFlagBits; +#define VK_FENCE_CREATE_SIGNALED_BIT 0x00000001U + +typedef VkFlags VkFenceCreateFlags; +typedef VkFlags VkSemaphoreCreateFlags; + +// Flag bits for VkEventCreateFlagBits +typedef VkFlags VkEventCreateFlagBits; +#define VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR 0x00000001U + +typedef VkFlags VkEventCreateFlags; + +// Flag bits for VkQueryPipelineStatisticFlagBits +typedef VkFlags VkQueryPipelineStatisticFlagBits; +#define VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT 0x00000001U +#define VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT 0x00000002U +#define VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT 0x00000004U +#define VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT 0x00000008U +#define VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT 0x00000010U +#define VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT 0x00000020U +#define VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT 0x00000040U +#define VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT 0x00000080U +#define VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT 0x00000100U +#define VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT 0x00000200U +#define VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT 0x00000400U + +typedef VkFlags VkQueryPipelineStatisticFlags; +typedef VkFlags VkQueryPoolCreateFlags; + +// Flag bits for VkQueryResultFlagBits +typedef VkFlags VkQueryResultFlagBits; +#define VK_QUERY_RESULT_64_BIT 0x00000001U +#define VK_QUERY_RESULT_WAIT_BIT 0x00000002U +#define VK_QUERY_RESULT_WITH_AVAILABILITY_BIT 0x00000004U +#define VK_QUERY_RESULT_PARTIAL_BIT 0x00000008U + +typedef VkFlags VkQueryResultFlags; + +// Flag bits for VkBufferCreateFlagBits +typedef VkFlags VkBufferCreateFlagBits; +#define VK_BUFFER_CREATE_SPARSE_BINDING_BIT 0x00000001U +#define VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT 0x00000002U +#define VK_BUFFER_CREATE_SPARSE_ALIASED_BIT 0x00000004U +#define VK_BUFFER_CREATE_PROTECTED_BIT 0x00000008U +#define VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT 0x00000010U + +typedef VkFlags VkBufferCreateFlags; + +// Flag bits for VkBufferUsageFlagBits +typedef VkFlags VkBufferUsageFlagBits; +#define VK_BUFFER_USAGE_TRANSFER_SRC_BIT 0x00000001U +#define VK_BUFFER_USAGE_TRANSFER_DST_BIT 0x00000002U +#define VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT 0x00000004U +#define VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT 0x00000008U +#define VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT 0x00000010U +#define VK_BUFFER_USAGE_STORAGE_BUFFER_BIT 0x00000020U +#define VK_BUFFER_USAGE_INDEX_BUFFER_BIT 0x00000040U +#define VK_BUFFER_USAGE_VERTEX_BUFFER_BIT 0x00000080U +#define VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT 0x00000100U +#define VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT 0x00020000U + +typedef VkFlags VkBufferUsageFlags; +typedef VkFlags VkBufferViewCreateFlags; + +// Flag bits for VkImageViewCreateFlagBits +typedef VkFlags VkImageViewCreateFlagBits; + +typedef VkFlags VkImageViewCreateFlags; + +// Flag bits for VkPipelineCacheCreateFlagBits +typedef VkFlags VkPipelineCacheCreateFlagBits; +#define VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT 0x00000004U +#define VK_PIPELINE_CACHE_CREATE_RESERVED_1_BIT_EXT 0x00000002U +#define VK_PIPELINE_CACHE_CREATE_READ_ONLY_BIT VK_PIPELINE_CACHE_CREATE_RESERVED_1_BIT_EXT + +typedef VkFlags VkPipelineCacheCreateFlags; + +// Flag bits for VkColorComponentFlagBits +typedef VkFlags VkColorComponentFlagBits; +#define VK_COLOR_COMPONENT_R_BIT 0x00000001U +#define VK_COLOR_COMPONENT_G_BIT 0x00000002U +#define VK_COLOR_COMPONENT_B_BIT 0x00000004U +#define VK_COLOR_COMPONENT_A_BIT 0x00000008U + +typedef VkFlags VkColorComponentFlags; + +// Flag bits for VkPipelineCreateFlagBits +typedef VkFlags VkPipelineCreateFlagBits; +#define VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT 0x00000001U +#define VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT 0x00000008U +#define VK_PIPELINE_CREATE_DISPATCH_BASE_BIT 0x00000010U +#define VK_PIPELINE_CREATE_DISPATCH_BASE VK_PIPELINE_CREATE_DISPATCH_BASE_BIT + +typedef VkFlags VkPipelineCreateFlags; + +// Flag bits for VkPipelineShaderStageCreateFlagBits +typedef VkFlags VkPipelineShaderStageCreateFlagBits; +#define VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT 0x00000001U +#define VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT 0x00000002U + +typedef VkFlags VkPipelineShaderStageCreateFlags; + +// Flag bits for VkShaderStageFlagBits +typedef VkFlags VkShaderStageFlagBits; +#define VK_SHADER_STAGE_VERTEX_BIT 0x00000001U +#define VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT 0x00000002U +#define VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT 0x00000004U +#define VK_SHADER_STAGE_GEOMETRY_BIT 0x00000008U +#define VK_SHADER_STAGE_FRAGMENT_BIT 0x00000010U +#define VK_SHADER_STAGE_COMPUTE_BIT 0x00000020U +#define VK_SHADER_STAGE_ALL_GRAPHICS 0x0000001FU +#define VK_SHADER_STAGE_ALL 0x7FFFFFFFU + + +// Flag bits for VkCullModeFlagBits +typedef VkFlags VkCullModeFlagBits; +#define VK_CULL_MODE_NONE 0U +#define VK_CULL_MODE_FRONT_BIT 0x00000001U +#define VK_CULL_MODE_BACK_BIT 0x00000002U +#define VK_CULL_MODE_FRONT_AND_BACK 0x00000003U + +typedef VkFlags VkCullModeFlags; +typedef VkFlags VkPipelineVertexInputStateCreateFlags; +typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; +typedef VkFlags VkPipelineTessellationStateCreateFlags; +typedef VkFlags VkPipelineViewportStateCreateFlags; +typedef VkFlags VkPipelineRasterizationStateCreateFlags; +typedef VkFlags VkPipelineMultisampleStateCreateFlags; +typedef VkFlags VkPipelineDepthStencilStateCreateFlags; +typedef VkFlags VkPipelineColorBlendStateCreateFlags; +typedef VkFlags VkPipelineDynamicStateCreateFlags; +typedef VkFlags VkPipelineLayoutCreateFlags; +typedef VkFlags VkShaderStageFlags; + +// Flag bits for VkSamplerCreateFlagBits +typedef VkFlags VkSamplerCreateFlagBits; + +typedef VkFlags VkSamplerCreateFlags; + +// Flag bits for VkDescriptorPoolCreateFlagBits +typedef VkFlags VkDescriptorPoolCreateFlagBits; +#define VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT 0x00000001U +#define VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT 0x00000002U + +typedef VkFlags VkDescriptorPoolCreateFlags; +typedef VkFlags VkDescriptorPoolResetFlags; + +// Flag bits for VkDescriptorSetLayoutCreateFlagBits +typedef VkFlags VkDescriptorSetLayoutCreateFlagBits; +#define VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT 0x00000002U + +typedef VkFlags VkDescriptorSetLayoutCreateFlags; + +// Flag bits for VkAttachmentDescriptionFlagBits +typedef VkFlags VkAttachmentDescriptionFlagBits; +#define VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT 0x00000001U + +typedef VkFlags VkAttachmentDescriptionFlags; + +// Flag bits for VkDependencyFlagBits +typedef VkFlags VkDependencyFlagBits; +#define VK_DEPENDENCY_BY_REGION_BIT 0x00000001U +#define VK_DEPENDENCY_DEVICE_GROUP_BIT 0x00000004U +#define VK_DEPENDENCY_VIEW_LOCAL_BIT 0x00000002U + +typedef VkFlags VkDependencyFlags; + +// Flag bits for VkFramebufferCreateFlagBits +typedef VkFlags VkFramebufferCreateFlagBits; +#define VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT 0x00000001U + +typedef VkFlags VkFramebufferCreateFlags; + +// Flag bits for VkRenderPassCreateFlagBits +typedef VkFlags VkRenderPassCreateFlagBits; + +typedef VkFlags VkRenderPassCreateFlags; + +// Flag bits for VkSubpassDescriptionFlagBits +typedef VkFlags VkSubpassDescriptionFlagBits; + +typedef VkFlags VkSubpassDescriptionFlags; + +// Flag bits for VkCommandPoolCreateFlagBits +typedef VkFlags VkCommandPoolCreateFlagBits; +#define VK_COMMAND_POOL_CREATE_TRANSIENT_BIT 0x00000001U +#define VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT 0x00000002U +#define VK_COMMAND_POOL_CREATE_PROTECTED_BIT 0x00000004U + +typedef VkFlags VkCommandPoolCreateFlags; + +// Flag bits for VkCommandPoolResetFlagBits +typedef VkFlags VkCommandPoolResetFlagBits; + +typedef VkFlags VkCommandPoolResetFlags; + +// Flag bits for VkCommandBufferUsageFlagBits +typedef VkFlags VkCommandBufferUsageFlagBits; +#define VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT 0x00000001U +#define VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT 0x00000002U +#define VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT 0x00000004U + +typedef VkFlags VkCommandBufferUsageFlags; + +// Flag bits for VkQueryControlFlagBits +typedef VkFlags VkQueryControlFlagBits; +#define VK_QUERY_CONTROL_PRECISE_BIT 0x00000001U + +typedef VkFlags VkQueryControlFlags; + +// Flag bits for VkCommandBufferResetFlagBits +typedef VkFlags VkCommandBufferResetFlagBits; +#define VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT 0x00000001U + +typedef VkFlags VkCommandBufferResetFlags; + +// Flag bits for VkStencilFaceFlagBits +typedef VkFlags VkStencilFaceFlagBits; +#define VK_STENCIL_FACE_FRONT_BIT 0x00000001U +#define VK_STENCIL_FACE_BACK_BIT 0x00000002U +#define VK_STENCIL_FACE_FRONT_AND_BACK 0x00000003U + +typedef VkFlags VkStencilFaceFlags; +typedef struct VkExtent2D { + uint32_t width; + uint32_t height; +} VkExtent2D; + +typedef struct VkExtent3D { + uint32_t width; + uint32_t height; + uint32_t depth; +} VkExtent3D; + +typedef struct VkOffset2D { + int32_t x; + int32_t y; +} VkOffset2D; + +typedef struct VkOffset3D { + int32_t x; + int32_t y; + int32_t z; +} VkOffset3D; + +typedef struct VkRect2D { + VkOffset2D offset; + VkExtent2D extent; +} VkRect2D; + +typedef struct VkBaseInStructure { + VkStructureType sType; + const struct VkBaseInStructure* pNext; +} VkBaseInStructure; + +typedef struct VkBaseOutStructure { + VkStructureType sType; + struct VkBaseOutStructure* pNext; +} VkBaseOutStructure; + +typedef struct VkBufferMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} VkBufferMemoryBarrier; + +typedef struct VkDispatchIndirectCommand { + uint32_t x; + uint32_t y; + uint32_t z; +} VkDispatchIndirectCommand; + +typedef struct VkDrawIndexedIndirectCommand { + uint32_t indexCount; + uint32_t instanceCount; + uint32_t firstIndex; + int32_t vertexOffset; + uint32_t firstInstance; +} VkDrawIndexedIndirectCommand; + +typedef struct VkDrawIndirectCommand { + uint32_t vertexCount; + uint32_t instanceCount; + uint32_t firstVertex; + uint32_t firstInstance; +} VkDrawIndirectCommand; + +typedef struct VkImageSubresourceRange { + VkImageAspectFlags aspectMask; + uint32_t baseMipLevel; + uint32_t levelCount; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkImageSubresourceRange; + +typedef struct VkImageMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} VkImageMemoryBarrier; + +typedef struct VkMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; +} VkMemoryBarrier; + +typedef struct VkPipelineCacheHeaderVersionOne { + uint32_t headerSize; + VkPipelineCacheHeaderVersion headerVersion; + uint32_t vendorID; + uint32_t deviceID; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; +} VkPipelineCacheHeaderVersionOne; + +typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( + void* pUserData, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + +typedef void (VKAPI_PTR *PFN_vkFreeFunction)( + void* pUserData, + void* pMemory); + +typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + +typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + +typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( + void* pUserData, + void* pOriginal, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + +typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); +typedef struct VkAllocationCallbacks { + void* pUserData; + PFN_vkAllocationFunction pfnAllocation; + PFN_vkReallocationFunction pfnReallocation; + PFN_vkFreeFunction pfnFree; + PFN_vkInternalAllocationNotification pfnInternalAllocation; + PFN_vkInternalFreeNotification pfnInternalFree; +} VkAllocationCallbacks; + +typedef struct VkApplicationInfo { + VkStructureType sType; + const void* pNext; + const char* pApplicationName; + uint32_t applicationVersion; + const char* pEngineName; + uint32_t engineVersion; + uint32_t apiVersion; +} VkApplicationInfo; + +typedef struct VkFormatProperties { + VkFormatFeatureFlags linearTilingFeatures; + VkFormatFeatureFlags optimalTilingFeatures; + VkFormatFeatureFlags bufferFeatures; +} VkFormatProperties; + +typedef struct VkImageFormatProperties { + VkExtent3D maxExtent; + uint32_t maxMipLevels; + uint32_t maxArrayLayers; + VkSampleCountFlags sampleCounts; + VkDeviceSize maxResourceSize; +} VkImageFormatProperties; + +typedef struct VkInstanceCreateInfo { + VkStructureType sType; + const void* pNext; + VkInstanceCreateFlags flags; + const VkApplicationInfo* pApplicationInfo; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; +} VkInstanceCreateInfo; + +typedef struct VkMemoryHeap { + VkDeviceSize size; + VkMemoryHeapFlags flags; +} VkMemoryHeap; + +typedef struct VkMemoryType { + VkMemoryPropertyFlags propertyFlags; + uint32_t heapIndex; +} VkMemoryType; + +typedef struct VkPhysicalDeviceFeatures { + VkBool32 robustBufferAccess; + VkBool32 fullDrawIndexUint32; + VkBool32 imageCubeArray; + VkBool32 independentBlend; + VkBool32 geometryShader; + VkBool32 tessellationShader; + VkBool32 sampleRateShading; + VkBool32 dualSrcBlend; + VkBool32 logicOp; + VkBool32 multiDrawIndirect; + VkBool32 drawIndirectFirstInstance; + VkBool32 depthClamp; + VkBool32 depthBiasClamp; + VkBool32 fillModeNonSolid; + VkBool32 depthBounds; + VkBool32 wideLines; + VkBool32 largePoints; + VkBool32 alphaToOne; + VkBool32 multiViewport; + VkBool32 samplerAnisotropy; + VkBool32 textureCompressionETC2; + VkBool32 textureCompressionASTC_LDR; + VkBool32 textureCompressionBC; + VkBool32 occlusionQueryPrecise; + VkBool32 pipelineStatisticsQuery; + VkBool32 vertexPipelineStoresAndAtomics; + VkBool32 fragmentStoresAndAtomics; + VkBool32 shaderTessellationAndGeometryPointSize; + VkBool32 shaderImageGatherExtended; + VkBool32 shaderStorageImageExtendedFormats; + VkBool32 shaderStorageImageMultisample; + VkBool32 shaderStorageImageReadWithoutFormat; + VkBool32 shaderStorageImageWriteWithoutFormat; + VkBool32 shaderUniformBufferArrayDynamicIndexing; + VkBool32 shaderSampledImageArrayDynamicIndexing; + VkBool32 shaderStorageBufferArrayDynamicIndexing; + VkBool32 shaderStorageImageArrayDynamicIndexing; + VkBool32 shaderClipDistance; + VkBool32 shaderCullDistance; + VkBool32 shaderFloat64; + VkBool32 shaderInt64; + VkBool32 shaderInt16; + VkBool32 shaderResourceResidency; + VkBool32 shaderResourceMinLod; + VkBool32 sparseBinding; + VkBool32 sparseResidencyBuffer; + VkBool32 sparseResidencyImage2D; + VkBool32 sparseResidencyImage3D; + VkBool32 sparseResidency2Samples; + VkBool32 sparseResidency4Samples; + VkBool32 sparseResidency8Samples; + VkBool32 sparseResidency16Samples; + VkBool32 sparseResidencyAliased; + VkBool32 variableMultisampleRate; + VkBool32 inheritedQueries; +} VkPhysicalDeviceFeatures; + +typedef struct VkPhysicalDeviceLimits { + uint32_t maxImageDimension1D; + uint32_t maxImageDimension2D; + uint32_t maxImageDimension3D; + uint32_t maxImageDimensionCube; + uint32_t maxImageArrayLayers; + uint32_t maxTexelBufferElements; + uint32_t maxUniformBufferRange; + uint32_t maxStorageBufferRange; + uint32_t maxPushConstantsSize; + uint32_t maxMemoryAllocationCount; + uint32_t maxSamplerAllocationCount; + VkDeviceSize bufferImageGranularity; + VkDeviceSize sparseAddressSpaceSize; + uint32_t maxBoundDescriptorSets; + uint32_t maxPerStageDescriptorSamplers; + uint32_t maxPerStageDescriptorUniformBuffers; + uint32_t maxPerStageDescriptorStorageBuffers; + uint32_t maxPerStageDescriptorSampledImages; + uint32_t maxPerStageDescriptorStorageImages; + uint32_t maxPerStageDescriptorInputAttachments; + uint32_t maxPerStageResources; + uint32_t maxDescriptorSetSamplers; + uint32_t maxDescriptorSetUniformBuffers; + uint32_t maxDescriptorSetUniformBuffersDynamic; + uint32_t maxDescriptorSetStorageBuffers; + uint32_t maxDescriptorSetStorageBuffersDynamic; + uint32_t maxDescriptorSetSampledImages; + uint32_t maxDescriptorSetStorageImages; + uint32_t maxDescriptorSetInputAttachments; + uint32_t maxVertexInputAttributes; + uint32_t maxVertexInputBindings; + uint32_t maxVertexInputAttributeOffset; + uint32_t maxVertexInputBindingStride; + uint32_t maxVertexOutputComponents; + uint32_t maxTessellationGenerationLevel; + uint32_t maxTessellationPatchSize; + uint32_t maxTessellationControlPerVertexInputComponents; + uint32_t maxTessellationControlPerVertexOutputComponents; + uint32_t maxTessellationControlPerPatchOutputComponents; + uint32_t maxTessellationControlTotalOutputComponents; + uint32_t maxTessellationEvaluationInputComponents; + uint32_t maxTessellationEvaluationOutputComponents; + uint32_t maxGeometryShaderInvocations; + uint32_t maxGeometryInputComponents; + uint32_t maxGeometryOutputComponents; + uint32_t maxGeometryOutputVertices; + uint32_t maxGeometryTotalOutputComponents; + uint32_t maxFragmentInputComponents; + uint32_t maxFragmentOutputAttachments; + uint32_t maxFragmentDualSrcAttachments; + uint32_t maxFragmentCombinedOutputResources; + uint32_t maxComputeSharedMemorySize; + uint32_t maxComputeWorkGroupCount[3]; + uint32_t maxComputeWorkGroupInvocations; + uint32_t maxComputeWorkGroupSize[3]; + uint32_t subPixelPrecisionBits; + uint32_t subTexelPrecisionBits; + uint32_t mipmapPrecisionBits; + uint32_t maxDrawIndexedIndexValue; + uint32_t maxDrawIndirectCount; + float maxSamplerLodBias; + float maxSamplerAnisotropy; + uint32_t maxViewports; + uint32_t maxViewportDimensions[2]; + float viewportBoundsRange[2]; + uint32_t viewportSubPixelBits; + size_t minMemoryMapAlignment; + VkDeviceSize minTexelBufferOffsetAlignment; + VkDeviceSize minUniformBufferOffsetAlignment; + VkDeviceSize minStorageBufferOffsetAlignment; + int32_t minTexelOffset; + uint32_t maxTexelOffset; + int32_t minTexelGatherOffset; + uint32_t maxTexelGatherOffset; + float minInterpolationOffset; + float maxInterpolationOffset; + uint32_t subPixelInterpolationOffsetBits; + uint32_t maxFramebufferWidth; + uint32_t maxFramebufferHeight; + uint32_t maxFramebufferLayers; + VkSampleCountFlags framebufferColorSampleCounts; + VkSampleCountFlags framebufferDepthSampleCounts; + VkSampleCountFlags framebufferStencilSampleCounts; + VkSampleCountFlags framebufferNoAttachmentsSampleCounts; + uint32_t maxColorAttachments; + VkSampleCountFlags sampledImageColorSampleCounts; + VkSampleCountFlags sampledImageIntegerSampleCounts; + VkSampleCountFlags sampledImageDepthSampleCounts; + VkSampleCountFlags sampledImageStencilSampleCounts; + VkSampleCountFlags storageImageSampleCounts; + uint32_t maxSampleMaskWords; + VkBool32 timestampComputeAndGraphics; + float timestampPeriod; + uint32_t maxClipDistances; + uint32_t maxCullDistances; + uint32_t maxCombinedClipAndCullDistances; + uint32_t discreteQueuePriorities; + float pointSizeRange[2]; + float lineWidthRange[2]; + float pointSizeGranularity; + float lineWidthGranularity; + VkBool32 strictLines; + VkBool32 standardSampleLocations; + VkDeviceSize optimalBufferCopyOffsetAlignment; + VkDeviceSize optimalBufferCopyRowPitchAlignment; + VkDeviceSize nonCoherentAtomSize; +} VkPhysicalDeviceLimits; + +typedef struct VkPhysicalDeviceMemoryProperties { + uint32_t memoryTypeCount; + VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; + uint32_t memoryHeapCount; + VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; +} VkPhysicalDeviceMemoryProperties; + +typedef struct VkPhysicalDeviceSparseProperties { + VkBool32 residencyStandard2DBlockShape; + VkBool32 residencyStandard2DMultisampleBlockShape; + VkBool32 residencyStandard3DBlockShape; + VkBool32 residencyAlignedMipSize; + VkBool32 residencyNonResidentStrict; +} VkPhysicalDeviceSparseProperties; + +typedef struct VkPhysicalDeviceProperties { + uint32_t apiVersion; + uint32_t driverVersion; + uint32_t vendorID; + uint32_t deviceID; + VkPhysicalDeviceType deviceType; + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; + VkPhysicalDeviceLimits limits; + VkPhysicalDeviceSparseProperties sparseProperties; +} VkPhysicalDeviceProperties; + +typedef struct VkQueueFamilyProperties { + VkQueueFlags queueFlags; + uint32_t queueCount; + uint32_t timestampValidBits; + VkExtent3D minImageTransferGranularity; +} VkQueueFamilyProperties; + +typedef struct VkDeviceQueueCreateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueCount; + const float* pQueuePriorities; +} VkDeviceQueueCreateInfo; + +typedef struct VkDeviceCreateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceCreateFlags flags; + uint32_t queueCreateInfoCount; + const VkDeviceQueueCreateInfo* pQueueCreateInfos; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; + const VkPhysicalDeviceFeatures* pEnabledFeatures; +} VkDeviceCreateInfo; + +typedef struct VkExtensionProperties { + char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; +} VkExtensionProperties; + +typedef struct VkLayerProperties { + char layerName[VK_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; + uint32_t implementationVersion; + char description[VK_MAX_DESCRIPTION_SIZE]; +} VkLayerProperties; + +typedef struct VkSubmitInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + const VkPipelineStageFlags* pWaitDstStageMask; + uint32_t commandBufferCount; + const VkCommandBuffer* pCommandBuffers; + uint32_t signalSemaphoreCount; + const VkSemaphore* pSignalSemaphores; +} VkSubmitInfo; + +typedef struct VkMappedMemoryRange { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; +} VkMappedMemoryRange; + +typedef struct VkMemoryAllocateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceSize allocationSize; + uint32_t memoryTypeIndex; +} VkMemoryAllocateInfo; + +typedef struct VkMemoryRequirements { + VkDeviceSize size; + VkDeviceSize alignment; + uint32_t memoryTypeBits; +} VkMemoryRequirements; + +typedef struct VkImageSubresource { + VkImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t arrayLayer; +} VkImageSubresource; + +typedef struct VkFenceCreateInfo { + VkStructureType sType; + const void* pNext; + VkFenceCreateFlags flags; +} VkFenceCreateInfo; + +typedef struct VkSemaphoreCreateInfo { + VkStructureType sType; + const void* pNext; + VkSemaphoreCreateFlags flags; +} VkSemaphoreCreateInfo; + +typedef struct VkEventCreateInfo { + VkStructureType sType; + const void* pNext; + VkEventCreateFlags flags; +} VkEventCreateInfo; + +typedef struct VkQueryPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkQueryPoolCreateFlags flags; + VkQueryType queryType; + uint32_t queryCount; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkQueryPoolCreateInfo; + +typedef struct VkBufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkBufferCreateFlags flags; + VkDeviceSize size; + VkBufferUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; +} VkBufferCreateInfo; + +typedef struct VkBufferViewCreateInfo { + VkStructureType sType; + const void* pNext; + VkBufferViewCreateFlags flags; + VkBuffer buffer; + VkFormat format; + VkDeviceSize offset; + VkDeviceSize range; +} VkBufferViewCreateInfo; + +typedef struct VkImageCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageCreateFlags flags; + VkImageType imageType; + VkFormat format; + VkExtent3D extent; + uint32_t mipLevels; + uint32_t arrayLayers; + VkSampleCountFlagBits samples; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + VkImageLayout initialLayout; +} VkImageCreateInfo; + +typedef struct VkSubresourceLayout { + VkDeviceSize offset; + VkDeviceSize size; + VkDeviceSize rowPitch; + VkDeviceSize arrayPitch; + VkDeviceSize depthPitch; +} VkSubresourceLayout; + +typedef struct VkComponentMapping { + VkComponentSwizzle r; + VkComponentSwizzle g; + VkComponentSwizzle b; + VkComponentSwizzle a; +} VkComponentMapping; + +typedef struct VkImageViewCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageViewCreateFlags flags; + VkImage image; + VkImageViewType viewType; + VkFormat format; + VkComponentMapping components; + VkImageSubresourceRange subresourceRange; +} VkImageViewCreateInfo; + +typedef struct VkPipelineCacheCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCacheCreateFlags flags; + size_t initialDataSize; + const void* pInitialData; +} VkPipelineCacheCreateInfo; + +typedef struct VkSpecializationMapEntry { + uint32_t constantID; + uint32_t offset; + size_t size; +} VkSpecializationMapEntry; + +typedef struct VkSpecializationInfo { + uint32_t mapEntryCount; + const VkSpecializationMapEntry* pMapEntries; + size_t dataSize; + const void* pData; +} VkSpecializationInfo; + +typedef struct VkPipelineShaderStageCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineShaderStageCreateFlags flags; + VkShaderStageFlagBits stage; + VkShaderModule module; + const char* pName; + const VkSpecializationInfo* pSpecializationInfo; +} VkPipelineShaderStageCreateInfo; + +typedef struct VkComputePipelineCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + VkPipelineShaderStageCreateInfo stage; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkComputePipelineCreateInfo; + +typedef struct VkVertexInputBindingDescription { + uint32_t binding; + uint32_t stride; + VkVertexInputRate inputRate; +} VkVertexInputBindingDescription; + +typedef struct VkVertexInputAttributeDescription { + uint32_t location; + uint32_t binding; + VkFormat format; + uint32_t offset; +} VkVertexInputAttributeDescription; + +typedef struct VkPipelineVertexInputStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineVertexInputStateCreateFlags flags; + uint32_t vertexBindingDescriptionCount; + const VkVertexInputBindingDescription* pVertexBindingDescriptions; + uint32_t vertexAttributeDescriptionCount; + const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; +} VkPipelineVertexInputStateCreateInfo; + +typedef struct VkPipelineInputAssemblyStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineInputAssemblyStateCreateFlags flags; + VkPrimitiveTopology topology; + VkBool32 primitiveRestartEnable; +} VkPipelineInputAssemblyStateCreateInfo; + +typedef struct VkPipelineTessellationStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineTessellationStateCreateFlags flags; + uint32_t patchControlPoints; +} VkPipelineTessellationStateCreateInfo; + +typedef struct VkViewport { + float x; + float y; + float width; + float height; + float minDepth; + float maxDepth; +} VkViewport; + +typedef struct VkPipelineViewportStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineViewportStateCreateFlags flags; + uint32_t viewportCount; + const VkViewport* pViewports; + uint32_t scissorCount; + const VkRect2D* pScissors; +} VkPipelineViewportStateCreateInfo; + +typedef struct VkPipelineRasterizationStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationStateCreateFlags flags; + VkBool32 depthClampEnable; + VkBool32 rasterizerDiscardEnable; + VkPolygonMode polygonMode; + VkCullModeFlags cullMode; + VkFrontFace frontFace; + VkBool32 depthBiasEnable; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; + float lineWidth; +} VkPipelineRasterizationStateCreateInfo; + +typedef struct VkPipelineMultisampleStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineMultisampleStateCreateFlags flags; + VkSampleCountFlagBits rasterizationSamples; + VkBool32 sampleShadingEnable; + float minSampleShading; + const VkSampleMask* pSampleMask; + VkBool32 alphaToCoverageEnable; + VkBool32 alphaToOneEnable; +} VkPipelineMultisampleStateCreateInfo; + +typedef struct VkStencilOpState { + VkStencilOp failOp; + VkStencilOp passOp; + VkStencilOp depthFailOp; + VkCompareOp compareOp; + uint32_t compareMask; + uint32_t writeMask; + uint32_t reference; +} VkStencilOpState; + +typedef struct VkPipelineDepthStencilStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineDepthStencilStateCreateFlags flags; + VkBool32 depthTestEnable; + VkBool32 depthWriteEnable; + VkCompareOp depthCompareOp; + VkBool32 depthBoundsTestEnable; + VkBool32 stencilTestEnable; + VkStencilOpState front; + VkStencilOpState back; + float minDepthBounds; + float maxDepthBounds; +} VkPipelineDepthStencilStateCreateInfo; + +typedef struct VkPipelineColorBlendAttachmentState { + VkBool32 blendEnable; + VkBlendFactor srcColorBlendFactor; + VkBlendFactor dstColorBlendFactor; + VkBlendOp colorBlendOp; + VkBlendFactor srcAlphaBlendFactor; + VkBlendFactor dstAlphaBlendFactor; + VkBlendOp alphaBlendOp; + VkColorComponentFlags colorWriteMask; +} VkPipelineColorBlendAttachmentState; + +typedef struct VkPipelineColorBlendStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineColorBlendStateCreateFlags flags; + VkBool32 logicOpEnable; + VkLogicOp logicOp; + uint32_t attachmentCount; + const VkPipelineColorBlendAttachmentState* pAttachments; + float blendConstants[4]; +} VkPipelineColorBlendStateCreateInfo; + +typedef struct VkPipelineDynamicStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineDynamicStateCreateFlags flags; + uint32_t dynamicStateCount; + const VkDynamicState* pDynamicStates; +} VkPipelineDynamicStateCreateInfo; + +typedef struct VkGraphicsPipelineCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + const VkPipelineVertexInputStateCreateInfo* pVertexInputState; + const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; + const VkPipelineTessellationStateCreateInfo* pTessellationState; + const VkPipelineViewportStateCreateInfo* pViewportState; + const VkPipelineRasterizationStateCreateInfo* pRasterizationState; + const VkPipelineMultisampleStateCreateInfo* pMultisampleState; + const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; + const VkPipelineColorBlendStateCreateInfo* pColorBlendState; + const VkPipelineDynamicStateCreateInfo* pDynamicState; + VkPipelineLayout layout; + VkRenderPass renderPass; + uint32_t subpass; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkGraphicsPipelineCreateInfo; + +typedef struct VkPushConstantRange { + VkShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; +} VkPushConstantRange; + +typedef struct VkPipelineLayoutCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineLayoutCreateFlags flags; + uint32_t setLayoutCount; + const VkDescriptorSetLayout* pSetLayouts; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges; +} VkPipelineLayoutCreateInfo; + +typedef struct VkSamplerCreateInfo { + VkStructureType sType; + const void* pNext; + VkSamplerCreateFlags flags; + VkFilter magFilter; + VkFilter minFilter; + VkSamplerMipmapMode mipmapMode; + VkSamplerAddressMode addressModeU; + VkSamplerAddressMode addressModeV; + VkSamplerAddressMode addressModeW; + float mipLodBias; + VkBool32 anisotropyEnable; + float maxAnisotropy; + VkBool32 compareEnable; + VkCompareOp compareOp; + float minLod; + float maxLod; + VkBorderColor borderColor; + VkBool32 unnormalizedCoordinates; +} VkSamplerCreateInfo; + +typedef struct VkCopyDescriptorSet { + VkStructureType sType; + const void* pNext; + VkDescriptorSet srcSet; + uint32_t srcBinding; + uint32_t srcArrayElement; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; +} VkCopyDescriptorSet; + +typedef struct VkDescriptorBufferInfo { + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize range; +} VkDescriptorBufferInfo; + +typedef struct VkDescriptorImageInfo { + VkSampler sampler; + VkImageView imageView; + VkImageLayout imageLayout; +} VkDescriptorImageInfo; + +typedef struct VkDescriptorPoolSize { + VkDescriptorType type; + uint32_t descriptorCount; +} VkDescriptorPoolSize; + +typedef struct VkDescriptorPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorPoolCreateFlags flags; + uint32_t maxSets; + uint32_t poolSizeCount; + const VkDescriptorPoolSize* pPoolSizes; +} VkDescriptorPoolCreateInfo; + +typedef struct VkDescriptorSetAllocateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorPool descriptorPool; + uint32_t descriptorSetCount; + const VkDescriptorSetLayout* pSetLayouts; +} VkDescriptorSetAllocateInfo; + +typedef struct VkDescriptorSetLayoutBinding { + uint32_t binding; + VkDescriptorType descriptorType; + uint32_t descriptorCount; + VkShaderStageFlags stageFlags; + const VkSampler* pImmutableSamplers; +} VkDescriptorSetLayoutBinding; + +typedef struct VkDescriptorSetLayoutCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorSetLayoutCreateFlags flags; + uint32_t bindingCount; + const VkDescriptorSetLayoutBinding* pBindings; +} VkDescriptorSetLayoutCreateInfo; + +typedef struct VkWriteDescriptorSet { + VkStructureType sType; + const void* pNext; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + const VkDescriptorImageInfo* pImageInfo; + const VkDescriptorBufferInfo* pBufferInfo; + const VkBufferView* pTexelBufferView; +} VkWriteDescriptorSet; + +typedef struct VkAttachmentDescription { + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription; + +typedef struct VkAttachmentReference { + uint32_t attachment; + VkImageLayout layout; +} VkAttachmentReference; + +typedef struct VkFramebufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkFramebufferCreateFlags flags; + VkRenderPass renderPass; + uint32_t attachmentCount; + const VkImageView* pAttachments; + uint32_t width; + uint32_t height; + uint32_t layers; +} VkFramebufferCreateInfo; + +typedef struct VkSubpassDescription { + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t inputAttachmentCount; + const VkAttachmentReference* pInputAttachments; + uint32_t colorAttachmentCount; + const VkAttachmentReference* pColorAttachments; + const VkAttachmentReference* pResolveAttachments; + const VkAttachmentReference* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments; +} VkSubpassDescription; + +typedef struct VkSubpassDependency { + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; +} VkSubpassDependency; + +typedef struct VkRenderPassCreateInfo { + VkStructureType sType; + const void* pNext; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + const VkAttachmentDescription* pAttachments; + uint32_t subpassCount; + const VkSubpassDescription* pSubpasses; + uint32_t dependencyCount; + const VkSubpassDependency* pDependencies; +} VkRenderPassCreateInfo; + +typedef struct VkCommandPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkCommandPoolCreateFlags flags; + uint32_t queueFamilyIndex; +} VkCommandPoolCreateInfo; + +typedef struct VkCommandBufferAllocateInfo { + VkStructureType sType; + const void* pNext; + VkCommandPool commandPool; + VkCommandBufferLevel level; + uint32_t commandBufferCount; +} VkCommandBufferAllocateInfo; + +typedef struct VkCommandBufferInheritanceInfo { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + uint32_t subpass; + VkFramebuffer framebuffer; + VkBool32 occlusionQueryEnable; + VkQueryControlFlags queryFlags; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkCommandBufferInheritanceInfo; + +typedef struct VkCommandBufferBeginInfo { + VkStructureType sType; + const void* pNext; + VkCommandBufferUsageFlags flags; + const VkCommandBufferInheritanceInfo* pInheritanceInfo; +} VkCommandBufferBeginInfo; + +typedef struct VkBufferCopy { + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; +} VkBufferCopy; + +typedef struct VkImageSubresourceLayers { + VkImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkImageSubresourceLayers; + +typedef struct VkBufferImageCopy { + VkDeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy; + +typedef union VkClearColorValue { + float float32[4]; + int32_t int32[4]; + uint32_t uint32[4]; +} VkClearColorValue; + +typedef struct VkClearDepthStencilValue { + float depth; + uint32_t stencil; +} VkClearDepthStencilValue; + +typedef union VkClearValue { + VkClearColorValue color; + VkClearDepthStencilValue depthStencil; +} VkClearValue; + +typedef struct VkClearAttachment { + VkImageAspectFlags aspectMask; + uint32_t colorAttachment; + VkClearValue clearValue; +} VkClearAttachment; + +typedef struct VkClearRect { + VkRect2D rect; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkClearRect; + +typedef struct VkImageBlit { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffsets[2]; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffsets[2]; +} VkImageBlit; + +typedef struct VkImageCopy { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageCopy; + +typedef struct VkImageResolve { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageResolve; + +typedef struct VkRenderPassBeginInfo { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + VkFramebuffer framebuffer; + VkRect2D renderArea; + uint32_t clearValueCount; + const VkClearValue* pClearValues; +} VkRenderPassBeginInfo; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); +typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); +typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); +typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue); +typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); +typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); +typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory); +typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); +typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); +typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); +typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); +typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); +typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); +typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); +typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); +typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); +typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); +typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); +typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); +typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); +typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); +typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); +typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); +typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); +typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); +typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); +typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); +typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); +typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); +typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); +typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); +typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); +typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); +typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); +typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); +typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); +typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); +typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); +typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents); +typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( + const VkInstanceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkInstance* pInstance); + +VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( + VkInstance instance, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( + VkInstance instance, + uint32_t* pPhysicalDeviceCount, + VkPhysicalDevice* pPhysicalDevices); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures* pFeatures); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties* pFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkImageFormatProperties* pImageFormatProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties* pQueueFamilyProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties* pMemoryProperties); + +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr( + VkInstance instance, + const char* pName); + +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr( + VkDevice device, + const char* pName); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( + VkPhysicalDevice physicalDevice, + const VkDeviceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDevice* pDevice); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( + VkDevice device, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( + VkPhysicalDevice physicalDevice, + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( + uint32_t* pPropertyCount, + VkLayerProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkLayerProperties* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( + VkDevice device, + uint32_t queueFamilyIndex, + uint32_t queueIndex, + VkQueue* pQueue); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo* pSubmits, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle( + VkQueue queue); + +VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle( + VkDevice device); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory( + VkDevice device, + const VkMemoryAllocateInfo* pAllocateInfo, + const VkAllocationCallbacks* pAllocator, + VkDeviceMemory* pMemory); + +VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize offset, + VkDeviceSize size, + VkMemoryMapFlags flags, + void** ppData); + +VKAPI_ATTR void VKAPI_CALL vkUnmapMemory( + VkDevice device, + VkDeviceMemory memory); + +VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); + +VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize* pCommittedMemoryInBytes); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory( + VkDevice device, + VkBuffer buffer, + VkDeviceMemory memory, + VkDeviceSize memoryOffset); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory( + VkDevice device, + VkImage image, + VkDeviceMemory memory, + VkDeviceSize memoryOffset); + +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements( + VkDevice device, + VkBuffer buffer, + VkMemoryRequirements* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements( + VkDevice device, + VkImage image, + VkMemoryRequirements* pMemoryRequirements); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence( + VkDevice device, + const VkFenceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +VKAPI_ATTR void VKAPI_CALL vkDestroyFence( + VkDevice device, + VkFence fence, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus( + VkDevice device, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences, + VkBool32 waitAll, + uint64_t timeout); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore( + VkDevice device, + const VkSemaphoreCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSemaphore* pSemaphore); + +VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( + VkDevice device, + VkSemaphore semaphore, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( + VkDevice device, + const VkEventCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkEvent* pEvent); + +VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( + VkDevice device, + VkEvent event, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool( + VkDevice device, + const VkQueryPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkQueryPool* pQueryPool); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + size_t dataSize, + void* pData, + VkDeviceSize stride, + VkQueryResultFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer( + VkDevice device, + const VkBufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBuffer* pBuffer); + +VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer( + VkDevice device, + VkBuffer buffer, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView( + VkDevice device, + const VkBufferViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferView* pView); + +VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView( + VkDevice device, + VkBufferView bufferView, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage( + VkDevice device, + const VkImageCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImage* pImage); + +VKAPI_ATTR void VKAPI_CALL vkDestroyImage( + VkDevice device, + VkImage image, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( + VkDevice device, + VkImage image, + const VkImageSubresource* pSubresource, + VkSubresourceLayout* pLayout); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView( + VkDevice device, + const VkImageViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImageView* pView); + +VKAPI_ATTR void VKAPI_CALL vkDestroyImageView( + VkDevice device, + VkImageView imageView, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache( + VkDevice device, + const VkPipelineCacheCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineCache* pPipelineCache); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache( + VkDevice device, + VkPipelineCache pipelineCache, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkComputePipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline( + VkDevice device, + VkPipeline pipeline, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout( + VkDevice device, + const VkPipelineLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineLayout* pPipelineLayout); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout( + VkDevice device, + VkPipelineLayout pipelineLayout, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler( + VkDevice device, + const VkSamplerCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSampler* pSampler); + +VKAPI_ATTR void VKAPI_CALL vkDestroySampler( + VkDevice device, + VkSampler sampler, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorSetLayout* pSetLayout); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout( + VkDevice device, + VkDescriptorSetLayout descriptorSetLayout, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool( + VkDevice device, + const VkDescriptorPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorPool* pDescriptorPool); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + VkDescriptorPoolResetFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets( + VkDevice device, + const VkDescriptorSetAllocateInfo* pAllocateInfo, + VkDescriptorSet* pDescriptorSets); + +VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets( + VkDevice device, + VkDescriptorPool descriptorPool, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets); + +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( + VkDevice device, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites, + uint32_t descriptorCopyCount, + const VkCopyDescriptorSet* pDescriptorCopies); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( + VkDevice device, + const VkFramebufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFramebuffer* pFramebuffer); + +VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer( + VkDevice device, + VkFramebuffer framebuffer, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( + VkDevice device, + const VkRenderPassCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); + +VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass( + VkDevice device, + VkRenderPass renderPass, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity( + VkDevice device, + VkRenderPass renderPass, + VkExtent2D* pGranularity); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( + VkDevice device, + const VkCommandPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCommandPool* pCommandPool); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolResetFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( + VkDevice device, + const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers); + +VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( + VkDevice device, + VkCommandPool commandPool, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); + +VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( + VkCommandBuffer commandBuffer, + const VkCommandBufferBeginInfo* pBeginInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( + VkCommandBuffer commandBuffer, + VkCommandBufferResetFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewport* pViewports); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor( + VkCommandBuffer commandBuffer, + uint32_t firstScissor, + uint32_t scissorCount, + const VkRect2D* pScissors); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth( + VkCommandBuffer commandBuffer, + float lineWidth); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias( + VkCommandBuffer commandBuffer, + float depthBiasConstantFactor, + float depthBiasClamp, + float depthBiasSlopeFactor); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants( + VkCommandBuffer commandBuffer, + const float blendConstants[4]); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds( + VkCommandBuffer commandBuffer, + float minDepthBounds, + float maxDepthBounds); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t compareMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t writeMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t reference); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkIndexType indexType); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdDraw( + VkCommandBuffer commandBuffer, + uint32_t vertexCount, + uint32_t instanceCount, + uint32_t firstVertex, + uint32_t firstInstance); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed( + VkCommandBuffer commandBuffer, + uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, + int32_t vertexOffset, + uint32_t firstInstance); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageBlit* pRegions, + VkFilter filter); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize dataSize, + const void* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize size, + uint32_t data); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearColorValue* pColor, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearDepthStencilValue* pDepthStencil, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkClearAttachment* pAttachments, + uint32_t rectCount, + const VkClearRect* pRects); + +VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageResolve* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers); + +VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + VkDependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize stride, + VkQueryResultFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( + VkCommandBuffer commandBuffer, + VkPipelineLayout layout, + VkShaderStageFlags stageFlags, + uint32_t offset, + uint32_t size, + const void* pValues); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + VkSubpassContents contents); + +VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass( + VkCommandBuffer commandBuffer, + VkSubpassContents contents); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( + VkCommandBuffer commandBuffer, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); +#endif + + +#define VK_VERSION_1_1 1 +// Vulkan 1.1 version number +#define VK_API_VERSION_1_1 VK_MAKE_API_VERSION(0, 1, 1, 0)// Patch version should always be set to 0 + +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion) +#define VK_MAX_DEVICE_GROUP_SIZE 32U +#define VK_LUID_SIZE 8U +#define VK_QUEUE_FAMILY_EXTERNAL (~1U) + +typedef enum VkPointClippingBehavior { + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, + VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF +} VkPointClippingBehavior; + +typedef enum VkTessellationDomainOrigin { + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, + VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF +} VkTessellationDomainOrigin; + +typedef enum VkSamplerYcbcrModelConversion { + VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF +} VkSamplerYcbcrModelConversion; + +typedef enum VkSamplerYcbcrRange { + VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, + VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1, + VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerYcbcrRange; + +typedef enum VkChromaLocation { + VK_CHROMA_LOCATION_COSITED_EVEN = 0, + VK_CHROMA_LOCATION_MIDPOINT = 1, + VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF +} VkChromaLocation; + +// Flag bits for VkSubgroupFeatureFlagBits +typedef VkFlags VkSubgroupFeatureFlagBits; +#define VK_SUBGROUP_FEATURE_BASIC_BIT 0x00000001U +#define VK_SUBGROUP_FEATURE_VOTE_BIT 0x00000002U +#define VK_SUBGROUP_FEATURE_ARITHMETIC_BIT 0x00000004U +#define VK_SUBGROUP_FEATURE_BALLOT_BIT 0x00000008U +#define VK_SUBGROUP_FEATURE_SHUFFLE_BIT 0x00000010U +#define VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT 0x00000020U +#define VK_SUBGROUP_FEATURE_CLUSTERED_BIT 0x00000040U +#define VK_SUBGROUP_FEATURE_QUAD_BIT 0x00000080U + +typedef VkFlags VkSubgroupFeatureFlags; + +// Flag bits for VkPeerMemoryFeatureFlagBits +typedef VkFlags VkPeerMemoryFeatureFlagBits; +#define VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT 0x00000001U +#define VK_PEER_MEMORY_FEATURE_COPY_DST_BIT 0x00000002U +#define VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT 0x00000004U +#define VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT 0x00000008U + +typedef VkFlags VkPeerMemoryFeatureFlags; + +// Flag bits for VkMemoryAllocateFlagBits +typedef VkFlags VkMemoryAllocateFlagBits; +#define VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT 0x00000001U +#define VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT 0x00000002U +#define VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT 0x00000004U + +typedef VkFlags VkMemoryAllocateFlags; + +// Flag bits for VkExternalMemoryHandleTypeFlagBits +typedef VkFlags VkExternalMemoryHandleTypeFlagBits; +#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT 0x00000001U +#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT 0x00000002U +#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT 0x00000004U +#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT 0x00000008U +#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT 0x00000010U +#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT 0x00000020U +#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT 0x00000040U +#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT 0x00000200U +#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT 0x00000080U +#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT 0x00000100U + +typedef VkFlags VkExternalMemoryHandleTypeFlags; + +// Flag bits for VkExternalMemoryFeatureFlagBits +typedef VkFlags VkExternalMemoryFeatureFlagBits; +#define VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT 0x00000001U +#define VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT 0x00000002U +#define VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT 0x00000004U + +typedef VkFlags VkExternalMemoryFeatureFlags; + +// Flag bits for VkExternalFenceHandleTypeFlagBits +typedef VkFlags VkExternalFenceHandleTypeFlagBits; +#define VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT 0x00000001U +#define VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT 0x00000002U +#define VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT 0x00000004U +#define VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT 0x00000008U + +typedef VkFlags VkExternalFenceHandleTypeFlags; + +// Flag bits for VkExternalFenceFeatureFlagBits +typedef VkFlags VkExternalFenceFeatureFlagBits; +#define VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT 0x00000001U +#define VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT 0x00000002U + +typedef VkFlags VkExternalFenceFeatureFlags; + +// Flag bits for VkFenceImportFlagBits +typedef VkFlags VkFenceImportFlagBits; +#define VK_FENCE_IMPORT_TEMPORARY_BIT 0x00000001U + +typedef VkFlags VkFenceImportFlags; + +// Flag bits for VkSemaphoreImportFlagBits +typedef VkFlags VkSemaphoreImportFlagBits; +#define VK_SEMAPHORE_IMPORT_TEMPORARY_BIT 0x00000001U + +typedef VkFlags VkSemaphoreImportFlags; + +// Flag bits for VkExternalSemaphoreHandleTypeFlagBits +typedef VkFlags VkExternalSemaphoreHandleTypeFlagBits; +#define VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT 0x00000001U +#define VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT 0x00000002U +#define VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT 0x00000004U +#define VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT 0x00000008U +#define VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT 0x00000010U +#define VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT + +typedef VkFlags VkExternalSemaphoreHandleTypeFlags; + +// Flag bits for VkExternalSemaphoreFeatureFlagBits +typedef VkFlags VkExternalSemaphoreFeatureFlagBits; +#define VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT 0x00000001U +#define VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT 0x00000002U + +typedef VkFlags VkExternalSemaphoreFeatureFlags; +typedef struct VkPhysicalDeviceSubgroupProperties { + VkStructureType sType; + void* pNext; + uint32_t subgroupSize; + VkShaderStageFlags supportedStages; + VkSubgroupFeatureFlags supportedOperations; + VkBool32 quadOperationsInAllStages; +} VkPhysicalDeviceSubgroupProperties; + +typedef struct VkBindBufferMemoryInfo { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} VkBindBufferMemoryInfo; + +typedef struct VkBindImageMemoryInfo { + VkStructureType sType; + const void* pNext; + VkImage image; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} VkBindImageMemoryInfo; + +typedef struct VkPhysicalDevice16BitStorageFeatures { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; +} VkPhysicalDevice16BitStorageFeatures; + +typedef struct VkMemoryDedicatedRequirements { + VkStructureType sType; + void* pNext; + VkBool32 prefersDedicatedAllocation; + VkBool32 requiresDedicatedAllocation; +} VkMemoryDedicatedRequirements; + +typedef struct VkMemoryDedicatedAllocateInfo { + VkStructureType sType; + const void* pNext; + VkImage image; + VkBuffer buffer; +} VkMemoryDedicatedAllocateInfo; + +typedef struct VkMemoryAllocateFlagsInfo { + VkStructureType sType; + const void* pNext; + VkMemoryAllocateFlags flags; + uint32_t deviceMask; +} VkMemoryAllocateFlagsInfo; + +typedef struct VkDeviceGroupRenderPassBeginInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceMask; + uint32_t deviceRenderAreaCount; + const VkRect2D* pDeviceRenderAreas; +} VkDeviceGroupRenderPassBeginInfo; + +typedef struct VkDeviceGroupCommandBufferBeginInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceMask; +} VkDeviceGroupCommandBufferBeginInfo; + +typedef struct VkDeviceGroupSubmitInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const uint32_t* pWaitSemaphoreDeviceIndices; + uint32_t commandBufferCount; + const uint32_t* pCommandBufferDeviceMasks; + uint32_t signalSemaphoreCount; + const uint32_t* pSignalSemaphoreDeviceIndices; +} VkDeviceGroupSubmitInfo; + +typedef struct VkBindBufferMemoryDeviceGroupInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; +} VkBindBufferMemoryDeviceGroupInfo; + +typedef struct VkBindImageMemoryDeviceGroupInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; + uint32_t splitInstanceBindRegionCount; + const VkRect2D* pSplitInstanceBindRegions; +} VkBindImageMemoryDeviceGroupInfo; + +typedef struct VkPhysicalDeviceGroupProperties { + VkStructureType sType; + void* pNext; + uint32_t physicalDeviceCount; + VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; + VkBool32 subsetAllocation; +} VkPhysicalDeviceGroupProperties; + +typedef struct VkDeviceGroupDeviceCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t physicalDeviceCount; + const VkPhysicalDevice* pPhysicalDevices; +} VkDeviceGroupDeviceCreateInfo; + +typedef struct VkBufferMemoryRequirementsInfo2 { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; +} VkBufferMemoryRequirementsInfo2; + +typedef struct VkImageMemoryRequirementsInfo2 { + VkStructureType sType; + const void* pNext; + VkImage image; +} VkImageMemoryRequirementsInfo2; + +typedef struct VkMemoryRequirements2 { + VkStructureType sType; + void* pNext; + VkMemoryRequirements memoryRequirements; +} VkMemoryRequirements2; + +typedef struct VkPhysicalDeviceFeatures2 { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceFeatures features; +} VkPhysicalDeviceFeatures2; + +typedef struct VkPhysicalDeviceProperties2 { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceProperties properties; +} VkPhysicalDeviceProperties2; + +typedef struct VkFormatProperties2 { + VkStructureType sType; + void* pNext; + VkFormatProperties formatProperties; +} VkFormatProperties2; + +typedef struct VkImageFormatProperties2 { + VkStructureType sType; + void* pNext; + VkImageFormatProperties imageFormatProperties; +} VkImageFormatProperties2; + +typedef struct VkPhysicalDeviceImageFormatInfo2 { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkImageType type; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; +} VkPhysicalDeviceImageFormatInfo2; + +typedef struct VkQueueFamilyProperties2 { + VkStructureType sType; + void* pNext; + VkQueueFamilyProperties queueFamilyProperties; +} VkQueueFamilyProperties2; + +typedef struct VkPhysicalDeviceMemoryProperties2 { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceMemoryProperties memoryProperties; +} VkPhysicalDeviceMemoryProperties2; + +typedef struct VkPhysicalDevicePointClippingProperties { + VkStructureType sType; + void* pNext; + VkPointClippingBehavior pointClippingBehavior; +} VkPhysicalDevicePointClippingProperties; + +typedef struct VkInputAttachmentAspectReference { + uint32_t subpass; + uint32_t inputAttachmentIndex; + VkImageAspectFlags aspectMask; +} VkInputAttachmentAspectReference; + +typedef struct VkRenderPassInputAttachmentAspectCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t aspectReferenceCount; + const VkInputAttachmentAspectReference* pAspectReferences; +} VkRenderPassInputAttachmentAspectCreateInfo; + +typedef struct VkImageViewUsageCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageUsageFlags usage; +} VkImageViewUsageCreateInfo; + +typedef struct VkPipelineTessellationDomainOriginStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkTessellationDomainOrigin domainOrigin; +} VkPipelineTessellationDomainOriginStateCreateInfo; + +typedef struct VkRenderPassMultiviewCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t subpassCount; + const uint32_t* pViewMasks; + uint32_t dependencyCount; + const int32_t* pViewOffsets; + uint32_t correlationMaskCount; + const uint32_t* pCorrelationMasks; +} VkRenderPassMultiviewCreateInfo; + +typedef struct VkPhysicalDeviceMultiviewFeatures { + VkStructureType sType; + void* pNext; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; +} VkPhysicalDeviceMultiviewFeatures; + +typedef struct VkPhysicalDeviceMultiviewProperties { + VkStructureType sType; + void* pNext; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; +} VkPhysicalDeviceMultiviewProperties; + +typedef struct VkPhysicalDeviceVariablePointersFeatures { + VkStructureType sType; + void* pNext; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; +} VkPhysicalDeviceVariablePointersFeatures; + +typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures; + +typedef struct VkPhysicalDeviceProtectedMemoryFeatures { + VkStructureType sType; + void* pNext; + VkBool32 protectedMemory; +} VkPhysicalDeviceProtectedMemoryFeatures; + +typedef struct VkPhysicalDeviceProtectedMemoryProperties { + VkStructureType sType; + void* pNext; + VkBool32 protectedNoFault; +} VkPhysicalDeviceProtectedMemoryProperties; + +typedef struct VkDeviceQueueInfo2 { + VkStructureType sType; + const void* pNext; + VkDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueIndex; +} VkDeviceQueueInfo2; + +typedef struct VkProtectedSubmitInfo { + VkStructureType sType; + const void* pNext; + VkBool32 protectedSubmit; +} VkProtectedSubmitInfo; + +typedef struct VkSamplerYcbcrConversionCreateInfo { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkSamplerYcbcrModelConversion ycbcrModel; + VkSamplerYcbcrRange ycbcrRange; + VkComponentMapping components; + VkChromaLocation xChromaOffset; + VkChromaLocation yChromaOffset; + VkFilter chromaFilter; + VkBool32 forceExplicitReconstruction; +} VkSamplerYcbcrConversionCreateInfo; + +typedef struct VkSamplerYcbcrConversionInfo { + VkStructureType sType; + const void* pNext; + VkSamplerYcbcrConversion conversion; +} VkSamplerYcbcrConversionInfo; + +typedef struct VkBindImagePlaneMemoryInfo { + VkStructureType sType; + const void* pNext; + VkImageAspectFlagBits planeAspect; +} VkBindImagePlaneMemoryInfo; + +typedef struct VkImagePlaneMemoryRequirementsInfo { + VkStructureType sType; + const void* pNext; + VkImageAspectFlagBits planeAspect; +} VkImagePlaneMemoryRequirementsInfo; + +typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures { + VkStructureType sType; + void* pNext; + VkBool32 samplerYcbcrConversion; +} VkPhysicalDeviceSamplerYcbcrConversionFeatures; + +typedef struct VkSamplerYcbcrConversionImageFormatProperties { + VkStructureType sType; + void* pNext; + uint32_t combinedImageSamplerDescriptorCount; +} VkSamplerYcbcrConversionImageFormatProperties; + +typedef struct VkExternalMemoryProperties { + VkExternalMemoryFeatureFlags externalMemoryFeatures; + VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes; + VkExternalMemoryHandleTypeFlags compatibleHandleTypes; +} VkExternalMemoryProperties; + +typedef struct VkPhysicalDeviceExternalImageFormatInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalImageFormatInfo; + +typedef struct VkExternalImageFormatProperties { + VkStructureType sType; + void* pNext; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalImageFormatProperties; + +typedef struct VkPhysicalDeviceExternalBufferInfo { + VkStructureType sType; + const void* pNext; + VkBufferCreateFlags flags; + VkBufferUsageFlags usage; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalBufferInfo; + +typedef struct VkExternalBufferProperties { + VkStructureType sType; + void* pNext; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalBufferProperties; + +typedef struct VkPhysicalDeviceIDProperties { + VkStructureType sType; + void* pNext; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE]; + uint32_t deviceNodeMask; + VkBool32 deviceLUIDValid; +} VkPhysicalDeviceIDProperties; + +typedef struct VkExternalMemoryImageCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryImageCreateInfo; + +typedef struct VkExternalMemoryBufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryBufferCreateInfo; + +typedef struct VkExportMemoryAllocateInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExportMemoryAllocateInfo; + +typedef struct VkPhysicalDeviceExternalFenceInfo { + VkStructureType sType; + const void* pNext; + VkExternalFenceHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalFenceInfo; + +typedef struct VkExternalFenceProperties { + VkStructureType sType; + void* pNext; + VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; + VkExternalFenceHandleTypeFlags compatibleHandleTypes; + VkExternalFenceFeatureFlags externalFenceFeatures; +} VkExternalFenceProperties; + +typedef struct VkExportFenceCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalFenceHandleTypeFlags handleTypes; +} VkExportFenceCreateInfo; + +typedef struct VkExportSemaphoreCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalSemaphoreHandleTypeFlags handleTypes; +} VkExportSemaphoreCreateInfo; + +typedef struct VkPhysicalDeviceExternalSemaphoreInfo { + VkStructureType sType; + const void* pNext; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalSemaphoreInfo; + +typedef struct VkExternalSemaphoreProperties { + VkStructureType sType; + void* pNext; + VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; + VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; + VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; +} VkExternalSemaphoreProperties; + +typedef struct VkPhysicalDeviceMaintenance3Properties { + VkStructureType sType; + void* pNext; + uint32_t maxPerSetDescriptors; + VkDeviceSize maxMemoryAllocationSize; +} VkPhysicalDeviceMaintenance3Properties; + +typedef struct VkDescriptorSetLayoutSupport { + VkStructureType sType; + void* pNext; + VkBool32 supported; +} VkDescriptorSetLayoutSupport; + +typedef struct VkPhysicalDeviceShaderDrawParametersFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderDrawParameters; +} VkPhysicalDeviceShaderDrawParametersFeatures; + +typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures; + +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion); +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); +typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); +typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion( + uint32_t* pApiVersion); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2( + VkDevice device, + uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2( + VkDevice device, + uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures( + VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask( + VkCommandBuffer commandBuffer, + uint32_t deviceMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase( + VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups( + VkInstance instance, + uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2( + VkDevice device, + const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2( + VkDevice device, + const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2* pFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2( + VkDevice device, + const VkDeviceQueueInfo2* pQueueInfo, + VkQueue* pQueue); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion( + VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion); + +VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion( + VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport); +#endif + + +#define VK_VERSION_1_2 1 +// Vulkan 1.2 version number +#define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0)// Patch version should always be set to 0 + +#define VK_MAX_DRIVER_NAME_SIZE 256U +#define VK_MAX_DRIVER_INFO_SIZE 256U + +typedef enum VkDriverId { + VK_DRIVER_ID_AMD_PROPRIETARY = 1, + VK_DRIVER_ID_AMD_OPEN_SOURCE = 2, + VK_DRIVER_ID_MESA_RADV = 3, + VK_DRIVER_ID_NVIDIA_PROPRIETARY = 4, + VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5, + VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6, + VK_DRIVER_ID_IMAGINATION_PROPRIETARY = 7, + VK_DRIVER_ID_QUALCOMM_PROPRIETARY = 8, + VK_DRIVER_ID_ARM_PROPRIETARY = 9, + VK_DRIVER_ID_GOOGLE_SWIFTSHADER = 10, + VK_DRIVER_ID_GGP_PROPRIETARY = 11, + VK_DRIVER_ID_BROADCOM_PROPRIETARY = 12, + VK_DRIVER_ID_MESA_LLVMPIPE = 13, + VK_DRIVER_ID_MOLTENVK = 14, + VK_DRIVER_ID_COREAVI_PROPRIETARY = 15, + VK_DRIVER_ID_JUICE_PROPRIETARY = 16, + VK_DRIVER_ID_VERISILICON_PROPRIETARY = 17, + VK_DRIVER_ID_MESA_TURNIP = 18, + VK_DRIVER_ID_MESA_V3DV = 19, + VK_DRIVER_ID_MESA_PANVK = 20, + VK_DRIVER_ID_SAMSUNG_PROPRIETARY = 21, + VK_DRIVER_ID_MAX_ENUM = 0x7FFFFFFF +} VkDriverId; + +typedef enum VkShaderFloatControlsIndependence { + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 0x7FFFFFFF +} VkShaderFloatControlsIndependence; + +typedef enum VkSamplerReductionMode { + VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0, + VK_SAMPLER_REDUCTION_MODE_MIN = 1, + VK_SAMPLER_REDUCTION_MODE_MAX = 2, + VK_SAMPLER_REDUCTION_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerReductionMode; + +typedef enum VkSemaphoreType { + VK_SEMAPHORE_TYPE_BINARY = 0, + VK_SEMAPHORE_TYPE_TIMELINE = 1, + VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkSemaphoreType; + +// Flag bits for VkResolveModeFlagBits +typedef VkFlags VkResolveModeFlagBits; +#define VK_RESOLVE_MODE_NONE 0U +#define VK_RESOLVE_MODE_SAMPLE_ZERO_BIT 0x00000001U +#define VK_RESOLVE_MODE_AVERAGE_BIT 0x00000002U +#define VK_RESOLVE_MODE_MIN_BIT 0x00000004U +#define VK_RESOLVE_MODE_MAX_BIT 0x00000008U + +typedef VkFlags VkResolveModeFlags; + +// Flag bits for VkDescriptorBindingFlagBits +typedef VkFlags VkDescriptorBindingFlagBits; +#define VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT 0x00000001U +#define VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT 0x00000002U +#define VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT 0x00000004U +#define VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT 0x00000008U + +typedef VkFlags VkDescriptorBindingFlags; + +// Flag bits for VkSemaphoreWaitFlagBits +typedef VkFlags VkSemaphoreWaitFlagBits; +#define VK_SEMAPHORE_WAIT_ANY_BIT 0x00000001U + +typedef VkFlags VkSemaphoreWaitFlags; +typedef struct VkPhysicalDeviceVulkan11Features { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; + VkBool32 protectedMemory; + VkBool32 samplerYcbcrConversion; + VkBool32 shaderDrawParameters; +} VkPhysicalDeviceVulkan11Features; + +typedef struct VkPhysicalDeviceVulkan11Properties { + VkStructureType sType; + void* pNext; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE]; + uint32_t deviceNodeMask; + VkBool32 deviceLUIDValid; + uint32_t subgroupSize; + VkShaderStageFlags subgroupSupportedStages; + VkSubgroupFeatureFlags subgroupSupportedOperations; + VkBool32 subgroupQuadOperationsInAllStages; + VkPointClippingBehavior pointClippingBehavior; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; + VkBool32 protectedNoFault; + uint32_t maxPerSetDescriptors; + VkDeviceSize maxMemoryAllocationSize; +} VkPhysicalDeviceVulkan11Properties; + +typedef struct VkPhysicalDeviceVulkan12Features { + VkStructureType sType; + void* pNext; + VkBool32 samplerMirrorClampToEdge; + VkBool32 drawIndirectCount; + VkBool32 storageBuffer8BitAccess; + VkBool32 uniformAndStorageBuffer8BitAccess; + VkBool32 storagePushConstant8; + VkBool32 shaderBufferInt64Atomics; + VkBool32 shaderSharedInt64Atomics; + VkBool32 shaderFloat16; + VkBool32 shaderInt8; + VkBool32 descriptorIndexing; + VkBool32 shaderInputAttachmentArrayDynamicIndexing; + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; + VkBool32 shaderUniformBufferArrayNonUniformIndexing; + VkBool32 shaderSampledImageArrayNonUniformIndexing; + VkBool32 shaderStorageBufferArrayNonUniformIndexing; + VkBool32 shaderStorageImageArrayNonUniformIndexing; + VkBool32 shaderInputAttachmentArrayNonUniformIndexing; + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; + VkBool32 descriptorBindingUniformBufferUpdateAfterBind; + VkBool32 descriptorBindingSampledImageUpdateAfterBind; + VkBool32 descriptorBindingStorageImageUpdateAfterBind; + VkBool32 descriptorBindingStorageBufferUpdateAfterBind; + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingUpdateUnusedWhilePending; + VkBool32 descriptorBindingPartiallyBound; + VkBool32 descriptorBindingVariableDescriptorCount; + VkBool32 runtimeDescriptorArray; + VkBool32 samplerFilterMinmax; + VkBool32 scalarBlockLayout; + VkBool32 imagelessFramebuffer; + VkBool32 uniformBufferStandardLayout; + VkBool32 shaderSubgroupExtendedTypes; + VkBool32 separateDepthStencilLayouts; + VkBool32 hostQueryReset; + VkBool32 timelineSemaphore; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; + VkBool32 vulkanMemoryModel; + VkBool32 vulkanMemoryModelDeviceScope; + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; + VkBool32 shaderOutputViewportIndex; + VkBool32 shaderOutputLayer; + VkBool32 subgroupBroadcastDynamicId; +} VkPhysicalDeviceVulkan12Features; + +typedef struct VkConformanceVersion { + uint8_t major; + uint8_t minor; + uint8_t subminor; + uint8_t patch; +} VkConformanceVersion; + +typedef struct VkPhysicalDeviceVulkan12Properties { + VkStructureType sType; + void* pNext; + VkDriverId driverID; + char driverName[VK_MAX_DRIVER_NAME_SIZE]; + char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; + VkConformanceVersion conformanceVersion; + VkShaderFloatControlsIndependence denormBehaviorIndependence; + VkShaderFloatControlsIndependence roundingModeIndependence; + VkBool32 shaderSignedZeroInfNanPreserveFloat16; + VkBool32 shaderSignedZeroInfNanPreserveFloat32; + VkBool32 shaderSignedZeroInfNanPreserveFloat64; + VkBool32 shaderDenormPreserveFloat16; + VkBool32 shaderDenormPreserveFloat32; + VkBool32 shaderDenormPreserveFloat64; + VkBool32 shaderDenormFlushToZeroFloat16; + VkBool32 shaderDenormFlushToZeroFloat32; + VkBool32 shaderDenormFlushToZeroFloat64; + VkBool32 shaderRoundingModeRTEFloat16; + VkBool32 shaderRoundingModeRTEFloat32; + VkBool32 shaderRoundingModeRTEFloat64; + VkBool32 shaderRoundingModeRTZFloat16; + VkBool32 shaderRoundingModeRTZFloat32; + VkBool32 shaderRoundingModeRTZFloat64; + uint32_t maxUpdateAfterBindDescriptorsInAllPools; + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; + VkBool32 shaderSampledImageArrayNonUniformIndexingNative; + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; + VkBool32 shaderStorageImageArrayNonUniformIndexingNative; + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; + VkBool32 robustBufferAccessUpdateAfterBind; + VkBool32 quadDivergentImplicitLod; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint32_t maxPerStageUpdateAfterBindResources; + uint32_t maxDescriptorSetUpdateAfterBindSamplers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; + VkResolveModeFlags supportedDepthResolveModes; + VkResolveModeFlags supportedStencilResolveModes; + VkBool32 independentResolveNone; + VkBool32 independentResolve; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; + uint64_t maxTimelineSemaphoreValueDifference; + VkSampleCountFlags framebufferIntegerColorSampleCounts; +} VkPhysicalDeviceVulkan12Properties; + +typedef struct VkImageFormatListCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t viewFormatCount; + const VkFormat* pViewFormats; +} VkImageFormatListCreateInfo; + +typedef struct VkAttachmentDescription2 { + VkStructureType sType; + const void* pNext; + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription2; + +typedef struct VkAttachmentReference2 { + VkStructureType sType; + const void* pNext; + uint32_t attachment; + VkImageLayout layout; + VkImageAspectFlags aspectMask; +} VkAttachmentReference2; + +typedef struct VkSubpassDescription2 { + VkStructureType sType; + const void* pNext; + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t viewMask; + uint32_t inputAttachmentCount; + const VkAttachmentReference2* pInputAttachments; + uint32_t colorAttachmentCount; + const VkAttachmentReference2* pColorAttachments; + const VkAttachmentReference2* pResolveAttachments; + const VkAttachmentReference2* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments; +} VkSubpassDescription2; + +typedef struct VkSubpassDependency2 { + VkStructureType sType; + const void* pNext; + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; + int32_t viewOffset; +} VkSubpassDependency2; + +typedef struct VkRenderPassCreateInfo2 { + VkStructureType sType; + const void* pNext; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + const VkAttachmentDescription2* pAttachments; + uint32_t subpassCount; + const VkSubpassDescription2* pSubpasses; + uint32_t dependencyCount; + const VkSubpassDependency2* pDependencies; + uint32_t correlatedViewMaskCount; + const uint32_t* pCorrelatedViewMasks; +} VkRenderPassCreateInfo2; + +typedef struct VkSubpassBeginInfo { + VkStructureType sType; + const void* pNext; + VkSubpassContents contents; +} VkSubpassBeginInfo; + +typedef struct VkSubpassEndInfo { + VkStructureType sType; + const void* pNext; +} VkSubpassEndInfo; + +typedef struct VkPhysicalDevice8BitStorageFeatures { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer8BitAccess; + VkBool32 uniformAndStorageBuffer8BitAccess; + VkBool32 storagePushConstant8; +} VkPhysicalDevice8BitStorageFeatures; + +typedef struct VkPhysicalDeviceDriverProperties { + VkStructureType sType; + void* pNext; + VkDriverId driverID; + char driverName[VK_MAX_DRIVER_NAME_SIZE]; + char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; + VkConformanceVersion conformanceVersion; +} VkPhysicalDeviceDriverProperties; + +typedef struct VkPhysicalDeviceShaderAtomicInt64Features { + VkStructureType sType; + void* pNext; + VkBool32 shaderBufferInt64Atomics; + VkBool32 shaderSharedInt64Atomics; +} VkPhysicalDeviceShaderAtomicInt64Features; + +typedef struct VkPhysicalDeviceShaderFloat16Int8Features { + VkStructureType sType; + void* pNext; + VkBool32 shaderFloat16; + VkBool32 shaderInt8; +} VkPhysicalDeviceShaderFloat16Int8Features; + +typedef struct VkPhysicalDeviceFloatControlsProperties { + VkStructureType sType; + void* pNext; + VkShaderFloatControlsIndependence denormBehaviorIndependence; + VkShaderFloatControlsIndependence roundingModeIndependence; + VkBool32 shaderSignedZeroInfNanPreserveFloat16; + VkBool32 shaderSignedZeroInfNanPreserveFloat32; + VkBool32 shaderSignedZeroInfNanPreserveFloat64; + VkBool32 shaderDenormPreserveFloat16; + VkBool32 shaderDenormPreserveFloat32; + VkBool32 shaderDenormPreserveFloat64; + VkBool32 shaderDenormFlushToZeroFloat16; + VkBool32 shaderDenormFlushToZeroFloat32; + VkBool32 shaderDenormFlushToZeroFloat64; + VkBool32 shaderRoundingModeRTEFloat16; + VkBool32 shaderRoundingModeRTEFloat32; + VkBool32 shaderRoundingModeRTEFloat64; + VkBool32 shaderRoundingModeRTZFloat16; + VkBool32 shaderRoundingModeRTZFloat32; + VkBool32 shaderRoundingModeRTZFloat64; +} VkPhysicalDeviceFloatControlsProperties; + +typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t bindingCount; + const VkDescriptorBindingFlags* pBindingFlags; +} VkDescriptorSetLayoutBindingFlagsCreateInfo; + +typedef struct VkPhysicalDeviceDescriptorIndexingFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderInputAttachmentArrayDynamicIndexing; + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; + VkBool32 shaderUniformBufferArrayNonUniformIndexing; + VkBool32 shaderSampledImageArrayNonUniformIndexing; + VkBool32 shaderStorageBufferArrayNonUniformIndexing; + VkBool32 shaderStorageImageArrayNonUniformIndexing; + VkBool32 shaderInputAttachmentArrayNonUniformIndexing; + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; + VkBool32 descriptorBindingUniformBufferUpdateAfterBind; + VkBool32 descriptorBindingSampledImageUpdateAfterBind; + VkBool32 descriptorBindingStorageImageUpdateAfterBind; + VkBool32 descriptorBindingStorageBufferUpdateAfterBind; + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingUpdateUnusedWhilePending; + VkBool32 descriptorBindingPartiallyBound; + VkBool32 descriptorBindingVariableDescriptorCount; + VkBool32 runtimeDescriptorArray; +} VkPhysicalDeviceDescriptorIndexingFeatures; + +typedef struct VkPhysicalDeviceDescriptorIndexingProperties { + VkStructureType sType; + void* pNext; + uint32_t maxUpdateAfterBindDescriptorsInAllPools; + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; + VkBool32 shaderSampledImageArrayNonUniformIndexingNative; + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; + VkBool32 shaderStorageImageArrayNonUniformIndexingNative; + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; + VkBool32 robustBufferAccessUpdateAfterBind; + VkBool32 quadDivergentImplicitLod; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint32_t maxPerStageUpdateAfterBindResources; + uint32_t maxDescriptorSetUpdateAfterBindSamplers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; +} VkPhysicalDeviceDescriptorIndexingProperties; + +typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo { + VkStructureType sType; + const void* pNext; + uint32_t descriptorSetCount; + const uint32_t* pDescriptorCounts; +} VkDescriptorSetVariableDescriptorCountAllocateInfo; + +typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport { + VkStructureType sType; + void* pNext; + uint32_t maxVariableDescriptorCount; +} VkDescriptorSetVariableDescriptorCountLayoutSupport; + +typedef struct VkSubpassDescriptionDepthStencilResolve { + VkStructureType sType; + const void* pNext; + VkResolveModeFlagBits depthResolveMode; + VkResolveModeFlagBits stencilResolveMode; + const VkAttachmentReference2* pDepthStencilResolveAttachment; +} VkSubpassDescriptionDepthStencilResolve; + +typedef struct VkPhysicalDeviceDepthStencilResolveProperties { + VkStructureType sType; + void* pNext; + VkResolveModeFlags supportedDepthResolveModes; + VkResolveModeFlags supportedStencilResolveModes; + VkBool32 independentResolveNone; + VkBool32 independentResolve; +} VkPhysicalDeviceDepthStencilResolveProperties; + +typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures { + VkStructureType sType; + void* pNext; + VkBool32 scalarBlockLayout; +} VkPhysicalDeviceScalarBlockLayoutFeatures; + +typedef struct VkImageStencilUsageCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageUsageFlags stencilUsage; +} VkImageStencilUsageCreateInfo; + +typedef struct VkSamplerReductionModeCreateInfo { + VkStructureType sType; + const void* pNext; + VkSamplerReductionMode reductionMode; +} VkSamplerReductionModeCreateInfo; + +typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties { + VkStructureType sType; + void* pNext; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; +} VkPhysicalDeviceSamplerFilterMinmaxProperties; + +typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures { + VkStructureType sType; + void* pNext; + VkBool32 vulkanMemoryModel; + VkBool32 vulkanMemoryModelDeviceScope; + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; +} VkPhysicalDeviceVulkanMemoryModelFeatures; + +typedef struct VkPhysicalDeviceImagelessFramebufferFeatures { + VkStructureType sType; + void* pNext; + VkBool32 imagelessFramebuffer; +} VkPhysicalDeviceImagelessFramebufferFeatures; + +typedef struct VkFramebufferAttachmentImageInfo { + VkStructureType sType; + const void* pNext; + VkImageCreateFlags flags; + VkImageUsageFlags usage; + uint32_t width; + uint32_t height; + uint32_t layerCount; + uint32_t viewFormatCount; + const VkFormat* pViewFormats; +} VkFramebufferAttachmentImageInfo; + +typedef struct VkFramebufferAttachmentsCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t attachmentImageInfoCount; + const VkFramebufferAttachmentImageInfo* pAttachmentImageInfos; +} VkFramebufferAttachmentsCreateInfo; + +typedef struct VkRenderPassAttachmentBeginInfo { + VkStructureType sType; + const void* pNext; + uint32_t attachmentCount; + const VkImageView* pAttachments; +} VkRenderPassAttachmentBeginInfo; + +typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures { + VkStructureType sType; + void* pNext; + VkBool32 uniformBufferStandardLayout; +} VkPhysicalDeviceUniformBufferStandardLayoutFeatures; + +typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderSubgroupExtendedTypes; +} VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures; + +typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures { + VkStructureType sType; + void* pNext; + VkBool32 separateDepthStencilLayouts; +} VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures; + +typedef struct VkAttachmentReferenceStencilLayout { + VkStructureType sType; + void* pNext; + VkImageLayout stencilLayout; +} VkAttachmentReferenceStencilLayout; + +typedef struct VkAttachmentDescriptionStencilLayout { + VkStructureType sType; + void* pNext; + VkImageLayout stencilInitialLayout; + VkImageLayout stencilFinalLayout; +} VkAttachmentDescriptionStencilLayout; + +typedef struct VkPhysicalDeviceHostQueryResetFeatures { + VkStructureType sType; + void* pNext; + VkBool32 hostQueryReset; +} VkPhysicalDeviceHostQueryResetFeatures; + +typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures { + VkStructureType sType; + void* pNext; + VkBool32 timelineSemaphore; +} VkPhysicalDeviceTimelineSemaphoreFeatures; + +typedef struct VkPhysicalDeviceTimelineSemaphoreProperties { + VkStructureType sType; + void* pNext; + uint64_t maxTimelineSemaphoreValueDifference; +} VkPhysicalDeviceTimelineSemaphoreProperties; + +typedef struct VkSemaphoreTypeCreateInfo { + VkStructureType sType; + const void* pNext; + VkSemaphoreType semaphoreType; + uint64_t initialValue; +} VkSemaphoreTypeCreateInfo; + +typedef struct VkTimelineSemaphoreSubmitInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreValueCount; + const uint64_t* pWaitSemaphoreValues; + uint32_t signalSemaphoreValueCount; + const uint64_t* pSignalSemaphoreValues; +} VkTimelineSemaphoreSubmitInfo; + +typedef struct VkSemaphoreWaitInfo { + VkStructureType sType; + const void* pNext; + VkSemaphoreWaitFlags flags; + uint32_t semaphoreCount; + const VkSemaphore* pSemaphores; + const uint64_t* pValues; +} VkSemaphoreWaitInfo; + +typedef struct VkSemaphoreSignalInfo { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + uint64_t value; +} VkSemaphoreSignalInfo; + +typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures { + VkStructureType sType; + void* pNext; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; +} VkPhysicalDeviceBufferDeviceAddressFeatures; + +typedef struct VkBufferDeviceAddressInfo { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; +} VkBufferDeviceAddressInfo; + +typedef struct VkBufferOpaqueCaptureAddressCreateInfo { + VkStructureType sType; + const void* pNext; + uint64_t opaqueCaptureAddress; +} VkBufferOpaqueCaptureAddressCreateInfo; + +typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo { + VkStructureType sType; + const void* pNext; + uint64_t opaqueCaptureAddress; +} VkMemoryOpaqueCaptureAddressAllocateInfo; + +typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; +} VkDeviceMemoryOpaqueCaptureAddressInfo; + +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); +typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); +typedef void (VKAPI_PTR *PFN_vkResetQueryPool)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValue)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue); +typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphores)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); +typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphore)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo); +typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddress)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCount( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCount( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2( + VkDevice device, + const VkRenderPassCreateInfo2* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + const VkSubpassBeginInfo* pSubpassBeginInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2( + VkCommandBuffer commandBuffer, + const VkSubpassBeginInfo* pSubpassBeginInfo, + const VkSubpassEndInfo* pSubpassEndInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2( + VkCommandBuffer commandBuffer, + const VkSubpassEndInfo* pSubpassEndInfo); + +VKAPI_ATTR void VKAPI_CALL vkResetQueryPool( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValue( + VkDevice device, + VkSemaphore semaphore, + uint64_t* pValue); + +VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphores( + VkDevice device, + const VkSemaphoreWaitInfo* pWaitInfo, + uint64_t timeout); + +VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphore( + VkDevice device, + const VkSemaphoreSignalInfo* pSignalInfo); + +VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddress( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); + +VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); + +VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddress( + VkDevice device, + const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); +#endif + + +#define VKSC_VERSION_1_0 1 +// Vulkan SC 1.0 version number +#define VKSC_API_VERSION_1_0 VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, 0)// Patch version should always be set to 0 + + +typedef enum VkFaultLevel { + VK_FAULT_LEVEL_UNASSIGNED = 0, + VK_FAULT_LEVEL_CRITICAL = 1, + VK_FAULT_LEVEL_RECOVERABLE = 2, + VK_FAULT_LEVEL_WARNING = 3, + VK_FAULT_LEVEL_MAX_ENUM = 0x7FFFFFFF +} VkFaultLevel; + +typedef enum VkFaultType { + VK_FAULT_TYPE_INVALID = 0, + VK_FAULT_TYPE_UNASSIGNED = 1, + VK_FAULT_TYPE_IMPLEMENTATION = 2, + VK_FAULT_TYPE_SYSTEM = 3, + VK_FAULT_TYPE_PHYSICAL_DEVICE = 4, + VK_FAULT_TYPE_COMMAND_BUFFER_FULL = 5, + VK_FAULT_TYPE_INVALID_API_USAGE = 6, + VK_FAULT_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkFaultType; + +typedef enum VkFaultQueryBehavior { + VK_FAULT_QUERY_BEHAVIOR_GET_AND_CLEAR_ALL_FAULTS = 0, + VK_FAULT_QUERY_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF +} VkFaultQueryBehavior; + +typedef enum VkPipelineMatchControl { + VK_PIPELINE_MATCH_CONTROL_APPLICATION_UUID_EXACT_MATCH = 0, + VK_PIPELINE_MATCH_CONTROL_MAX_ENUM = 0x7FFFFFFF +} VkPipelineMatchControl; + +typedef enum VkPipelineCacheValidationVersion { + VK_PIPELINE_CACHE_VALIDATION_VERSION_SAFETY_CRITICAL_ONE = 1, + VK_PIPELINE_CACHE_VALIDATION_VERSION_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCacheValidationVersion; +typedef struct VkPhysicalDeviceVulkanSC10Features { + VkStructureType sType; + void* pNext; + VkBool32 shaderAtomicInstructions; +} VkPhysicalDeviceVulkanSC10Features; + +typedef struct VkPhysicalDeviceVulkanSC10Properties { + VkStructureType sType; + void* pNext; + VkBool32 deviceNoDynamicHostAllocations; + VkBool32 deviceDestroyFreesMemory; + VkBool32 commandPoolMultipleCommandBuffersRecording; + VkBool32 commandPoolResetCommandBuffer; + VkBool32 commandBufferSimultaneousUse; + VkBool32 secondaryCommandBufferNullOrImagelessFramebuffer; + VkBool32 recycleDescriptorSetMemory; + VkBool32 recyclePipelineMemory; + uint32_t maxRenderPassSubpasses; + uint32_t maxRenderPassDependencies; + uint32_t maxSubpassInputAttachments; + uint32_t maxSubpassPreserveAttachments; + uint32_t maxFramebufferAttachments; + uint32_t maxDescriptorSetLayoutBindings; + uint32_t maxQueryFaultCount; + uint32_t maxCallbackFaultCount; + uint32_t maxCommandPoolCommandBuffers; + VkDeviceSize maxCommandBufferSize; +} VkPhysicalDeviceVulkanSC10Properties; + +typedef struct VkPipelinePoolSize { + VkStructureType sType; + const void* pNext; + VkDeviceSize poolEntrySize; + uint32_t poolEntryCount; +} VkPipelinePoolSize; + +typedef struct VkDeviceObjectReservationCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t pipelineCacheCreateInfoCount; + const VkPipelineCacheCreateInfo* pPipelineCacheCreateInfos; + uint32_t pipelinePoolSizeCount; + const VkPipelinePoolSize* pPipelinePoolSizes; + uint32_t semaphoreRequestCount; + uint32_t commandBufferRequestCount; + uint32_t fenceRequestCount; + uint32_t deviceMemoryRequestCount; + uint32_t bufferRequestCount; + uint32_t imageRequestCount; + uint32_t eventRequestCount; + uint32_t queryPoolRequestCount; + uint32_t bufferViewRequestCount; + uint32_t imageViewRequestCount; + uint32_t layeredImageViewRequestCount; + uint32_t pipelineCacheRequestCount; + uint32_t pipelineLayoutRequestCount; + uint32_t renderPassRequestCount; + uint32_t graphicsPipelineRequestCount; + uint32_t computePipelineRequestCount; + uint32_t descriptorSetLayoutRequestCount; + uint32_t samplerRequestCount; + uint32_t descriptorPoolRequestCount; + uint32_t descriptorSetRequestCount; + uint32_t framebufferRequestCount; + uint32_t commandPoolRequestCount; + uint32_t samplerYcbcrConversionRequestCount; + uint32_t surfaceRequestCount; + uint32_t swapchainRequestCount; + uint32_t displayModeRequestCount; + uint32_t subpassDescriptionRequestCount; + uint32_t attachmentDescriptionRequestCount; + uint32_t descriptorSetLayoutBindingRequestCount; + uint32_t descriptorSetLayoutBindingLimit; + uint32_t maxImageViewMipLevels; + uint32_t maxImageViewArrayLayers; + uint32_t maxLayeredImageViewMipLevels; + uint32_t maxOcclusionQueriesPerPool; + uint32_t maxPipelineStatisticsQueriesPerPool; + uint32_t maxTimestampQueriesPerPool; + uint32_t maxImmutableSamplersPerDescriptorSetLayout; +} VkDeviceObjectReservationCreateInfo; + +typedef struct VkCommandPoolMemoryReservationCreateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceSize commandPoolReservedSize; + uint32_t commandPoolMaxCommandBuffers; +} VkCommandPoolMemoryReservationCreateInfo; + +typedef struct VkCommandPoolMemoryConsumption { + VkStructureType sType; + void* pNext; + VkDeviceSize commandPoolAllocated; + VkDeviceSize commandPoolReservedSize; + VkDeviceSize commandBufferAllocated; +} VkCommandPoolMemoryConsumption; + +typedef struct VkFaultData { + VkStructureType sType; + void* pNext; + VkFaultLevel faultLevel; + VkFaultType faultType; +} VkFaultData; + +typedef void (VKAPI_PTR *PFN_vkFaultCallbackFunction)( + VkBool32 unrecordedFaults, + uint32_t faultCount, + const VkFaultData* pFaults); + +typedef struct VkFaultCallbackInfo { + VkStructureType sType; + void* pNext; + uint32_t faultCount; + VkFaultData* pFaults; + PFN_vkFaultCallbackFunction pfnFaultCallback; +} VkFaultCallbackInfo; + +typedef struct VkPipelineOfflineCreateInfo { + VkStructureType sType; + const void* pNext; + uint8_t pipelineIdentifier[VK_UUID_SIZE]; + VkPipelineMatchControl matchControl; + VkDeviceSize poolEntrySize; +} VkPipelineOfflineCreateInfo; + +typedef struct VkPipelineCacheStageValidationIndexEntry { + uint64_t codeSize; + uint64_t codeOffset; +} VkPipelineCacheStageValidationIndexEntry; + +typedef struct VkPipelineCacheSafetyCriticalIndexEntry { + uint8_t pipelineIdentifier[VK_UUID_SIZE]; + uint64_t pipelineMemorySize; + uint64_t jsonSize; + uint64_t jsonOffset; + uint32_t stageIndexCount; + uint32_t stageIndexStride; + uint64_t stageIndexOffset; +} VkPipelineCacheSafetyCriticalIndexEntry; + +typedef struct VkPipelineCacheHeaderVersionSafetyCriticalOne { + VkPipelineCacheHeaderVersionOne headerVersionOne; + VkPipelineCacheValidationVersion validationVersion; + uint32_t implementationData; + uint32_t pipelineIndexCount; + uint32_t pipelineIndexStride; + uint64_t pipelineIndexOffset; +} VkPipelineCacheHeaderVersionSafetyCriticalOne; + +typedef void (VKAPI_PTR *PFN_vkGetCommandPoolMemoryConsumption)(VkDevice device, VkCommandPool commandPool, VkCommandBuffer commandBuffer, VkCommandPoolMemoryConsumption* pConsumption); +typedef VkResult (VKAPI_PTR *PFN_vkGetFaultData)(VkDevice device, VkFaultQueryBehavior faultQueryBehavior, VkBool32* pUnrecordedFaults, uint32_t* pFaultCount, VkFaultData* pFaults); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetCommandPoolMemoryConsumption( + VkDevice device, + VkCommandPool commandPool, + VkCommandBuffer commandBuffer, + VkCommandPoolMemoryConsumption* pConsumption); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFaultData( + VkDevice device, + VkFaultQueryBehavior faultQueryBehavior, + VkBool32* pUnrecordedFaults, + uint32_t* pFaultCount, + VkFaultData* pFaults); +#endif + + +#define VK_KHR_surface 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) +#define VK_KHR_SURFACE_SPEC_VERSION 25 +#define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" + +typedef enum VkPresentModeKHR { + VK_PRESENT_MODE_IMMEDIATE_KHR = 0, + VK_PRESENT_MODE_MAILBOX_KHR = 1, + VK_PRESENT_MODE_FIFO_KHR = 2, + VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, + VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000, + VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001, + VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPresentModeKHR; + +typedef enum VkColorSpaceKHR { + VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, + VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001, + VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002, + VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104003, + VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004, + VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005, + VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006, + VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007, + VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008, + VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009, + VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010, + VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011, + VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012, + VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013, + VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014, + VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkColorSpaceKHR; + +// Flag bits for VkSurfaceTransformFlagBitsKHR +typedef VkFlags VkSurfaceTransformFlagBitsKHR; +#define VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR 0x00000001U +#define VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR 0x00000002U +#define VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR 0x00000004U +#define VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR 0x00000008U +#define VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR 0x00000010U +#define VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR 0x00000020U +#define VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR 0x00000040U +#define VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR 0x00000080U +#define VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR 0x00000100U + + +// Flag bits for VkCompositeAlphaFlagBitsKHR +typedef VkFlags VkCompositeAlphaFlagBitsKHR; +#define VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR 0x00000001U +#define VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR 0x00000002U +#define VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR 0x00000004U +#define VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR 0x00000008U + +typedef VkFlags VkCompositeAlphaFlagsKHR; +typedef VkFlags VkSurfaceTransformFlagsKHR; +typedef struct VkSurfaceCapabilitiesKHR { + uint32_t minImageCount; + uint32_t maxImageCount; + VkExtent2D currentExtent; + VkExtent2D minImageExtent; + VkExtent2D maxImageExtent; + uint32_t maxImageArrayLayers; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkSurfaceTransformFlagBitsKHR currentTransform; + VkCompositeAlphaFlagsKHR supportedCompositeAlpha; + VkImageUsageFlags supportedUsageFlags; +} VkSurfaceCapabilitiesKHR; + +typedef struct VkSurfaceFormatKHR { + VkFormat format; + VkColorSpaceKHR colorSpace; +} VkSurfaceFormatKHR; + +typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( + VkInstance instance, + VkSurfaceKHR surface, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + VkSurfaceKHR surface, + VkBool32* pSupported); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormatKHR* pSurfaceFormats); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes); +#endif + + +#define VK_KHR_swapchain 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) +#define VK_KHR_SWAPCHAIN_SPEC_VERSION 70 +#define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" + +// Flag bits for VkSwapchainCreateFlagBitsKHR +typedef VkFlags VkSwapchainCreateFlagBitsKHR; +#define VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR 0x00000001U +#define VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR 0x00000002U +#define VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR 0x00000004U + +typedef VkFlags VkSwapchainCreateFlagsKHR; + +// Flag bits for VkDeviceGroupPresentModeFlagBitsKHR +typedef VkFlags VkDeviceGroupPresentModeFlagBitsKHR; +#define VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR 0x00000001U +#define VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR 0x00000002U +#define VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR 0x00000004U +#define VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR 0x00000008U + +typedef VkFlags VkDeviceGroupPresentModeFlagsKHR; +typedef struct VkSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainCreateFlagsKHR flags; + VkSurfaceKHR surface; + uint32_t minImageCount; + VkFormat imageFormat; + VkColorSpaceKHR imageColorSpace; + VkExtent2D imageExtent; + uint32_t imageArrayLayers; + VkImageUsageFlags imageUsage; + VkSharingMode imageSharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + VkSurfaceTransformFlagBitsKHR preTransform; + VkCompositeAlphaFlagBitsKHR compositeAlpha; + VkPresentModeKHR presentMode; + VkBool32 clipped; + VkSwapchainKHR oldSwapchain; +} VkSwapchainCreateInfoKHR; + +typedef struct VkPresentInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + uint32_t swapchainCount; + const VkSwapchainKHR* pSwapchains; + const uint32_t* pImageIndices; + VkResult* pResults; +} VkPresentInfoKHR; + +typedef struct VkImageSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; +} VkImageSwapchainCreateInfoKHR; + +typedef struct VkBindImageMemorySwapchainInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + uint32_t imageIndex; +} VkBindImageMemorySwapchainInfoKHR; + +typedef struct VkAcquireNextImageInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + uint64_t timeout; + VkSemaphore semaphore; + VkFence fence; + uint32_t deviceMask; +} VkAcquireNextImageInfoKHR; + +typedef struct VkDeviceGroupPresentCapabilitiesKHR { + VkStructureType sType; + void* pNext; + uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; + VkDeviceGroupPresentModeFlagsKHR modes; +} VkDeviceGroupPresentCapabilitiesKHR; + +typedef struct VkDeviceGroupPresentInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const uint32_t* pDeviceMasks; + VkDeviceGroupPresentModeFlagBitsKHR mode; +} VkDeviceGroupPresentInfoKHR; + +typedef struct VkDeviceGroupSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceGroupPresentModeFlagsKHR modes; +} VkDeviceGroupSwapchainCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); +typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( + VkDevice device, + const VkSwapchainCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchain); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pSwapchainImageCount, + VkImage* pSwapchainImages); + +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint64_t timeout, + VkSemaphore semaphore, + VkFence fence, + uint32_t* pImageIndex); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( + VkQueue queue, + const VkPresentInfoKHR* pPresentInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR( + VkDevice device, + VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR( + VkDevice device, + VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHR* pModes); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pRectCount, + VkRect2D* pRects); + +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR( + VkDevice device, + const VkAcquireNextImageInfoKHR* pAcquireInfo, + uint32_t* pImageIndex); +#endif + + +#define VK_KHR_display 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) +#define VK_KHR_DISPLAY_SPEC_VERSION 23 +#define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display" +typedef VkFlags VkDisplayModeCreateFlagsKHR; + +// Flag bits for VkDisplayPlaneAlphaFlagBitsKHR +typedef VkFlags VkDisplayPlaneAlphaFlagBitsKHR; +#define VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR 0x00000001U +#define VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR 0x00000002U +#define VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR 0x00000004U +#define VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR 0x00000008U + +typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; +typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; +typedef struct VkDisplayModeParametersKHR { + VkExtent2D visibleRegion; + uint32_t refreshRate; +} VkDisplayModeParametersKHR; + +typedef struct VkDisplayModeCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDisplayModeCreateFlagsKHR flags; + VkDisplayModeParametersKHR parameters; +} VkDisplayModeCreateInfoKHR; + +typedef struct VkDisplayModePropertiesKHR { + VkDisplayModeKHR displayMode; + VkDisplayModeParametersKHR parameters; +} VkDisplayModePropertiesKHR; + +typedef struct VkDisplayPlaneCapabilitiesKHR { + VkDisplayPlaneAlphaFlagsKHR supportedAlpha; + VkOffset2D minSrcPosition; + VkOffset2D maxSrcPosition; + VkExtent2D minSrcExtent; + VkExtent2D maxSrcExtent; + VkOffset2D minDstPosition; + VkOffset2D maxDstPosition; + VkExtent2D minDstExtent; + VkExtent2D maxDstExtent; +} VkDisplayPlaneCapabilitiesKHR; + +typedef struct VkDisplayPlanePropertiesKHR { + VkDisplayKHR currentDisplay; + uint32_t currentStackIndex; +} VkDisplayPlanePropertiesKHR; + +typedef struct VkDisplayPropertiesKHR { + VkDisplayKHR display; + const char* displayName; + VkExtent2D physicalDimensions; + VkExtent2D physicalResolution; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkBool32 planeReorderPossible; + VkBool32 persistentContent; +} VkDisplayPropertiesKHR; + +typedef struct VkDisplaySurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDisplaySurfaceCreateFlagsKHR flags; + VkDisplayModeKHR displayMode; + uint32_t planeIndex; + uint32_t planeStackIndex; + VkSurfaceTransformFlagBitsKHR transform; + float globalAlpha; + VkDisplayPlaneAlphaFlagBitsKHR alphaMode; + VkExtent2D imageExtent; +} VkDisplaySurfaceCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlanePropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR( + VkPhysicalDevice physicalDevice, + uint32_t planeIndex, + uint32_t* pDisplayCount, + VkDisplayKHR* pDisplays); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModePropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + const VkDisplayModeCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDisplayModeKHR* pMode); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayModeKHR mode, + uint32_t planeIndex, + VkDisplayPlaneCapabilitiesKHR* pCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR( + VkInstance instance, + const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + + +#define VK_KHR_display_swapchain 1 +#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 10 +#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain" +typedef struct VkDisplayPresentInfoKHR { + VkStructureType sType; + const void* pNext; + VkRect2D srcRect; + VkRect2D dstRect; + VkBool32 persistent; +} VkDisplayPresentInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR( + VkDevice device, + uint32_t swapchainCount, + const VkSwapchainCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchains); +#endif + + +#define VK_KHR_external_memory_fd 1 +#define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd" +typedef struct VkImportMemoryFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + int fd; +} VkImportMemoryFdInfoKHR; + +typedef struct VkMemoryFdPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryFdPropertiesKHR; + +typedef struct VkMemoryGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkMemoryGetFdInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR( + VkDevice device, + const VkMemoryGetFdInfoKHR* pGetFdInfo, + int* pFd); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + int fd, + VkMemoryFdPropertiesKHR* pMemoryFdProperties); +#endif + + +#define VK_KHR_external_semaphore_fd 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd" +typedef struct VkImportSemaphoreFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkSemaphoreImportFlags flags; + VkExternalSemaphoreHandleTypeFlagBits handleType; + int fd; +} VkImportSemaphoreFdInfoKHR; + +typedef struct VkSemaphoreGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkSemaphoreGetFdInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR( + VkDevice device, + const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR( + VkDevice device, + const VkSemaphoreGetFdInfoKHR* pGetFdInfo, + int* pFd); +#endif + + +#define VK_KHR_incremental_present 1 +#define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 2 +#define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present" +typedef struct VkRectLayerKHR { + VkOffset2D offset; + VkExtent2D extent; + uint32_t layer; +} VkRectLayerKHR; + +typedef struct VkPresentRegionKHR { + uint32_t rectangleCount; + const VkRectLayerKHR* pRectangles; +} VkPresentRegionKHR; + +typedef struct VkPresentRegionsKHR { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkPresentRegionKHR* pRegions; +} VkPresentRegionsKHR; + + + +#define VK_KHR_shared_presentable_image 1 +#define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1 +#define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image" +typedef struct VkSharedPresentSurfaceCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkImageUsageFlags sharedPresentSupportedUsageFlags; +} VkSharedPresentSurfaceCapabilitiesKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR( + VkDevice device, + VkSwapchainKHR swapchain); +#endif + + +#define VK_KHR_external_fence_fd 1 +#define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd" +typedef struct VkImportFenceFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkFenceImportFlags flags; + VkExternalFenceHandleTypeFlagBits handleType; + int fd; +} VkImportFenceFdInfoKHR; + +typedef struct VkFenceGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkExternalFenceHandleTypeFlagBits handleType; +} VkFenceGetFdInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR( + VkDevice device, + const VkImportFenceFdInfoKHR* pImportFenceFdInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR( + VkDevice device, + const VkFenceGetFdInfoKHR* pGetFdInfo, + int* pFd); +#endif + + +#define VK_KHR_performance_query 1 +#define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1 +#define VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME "VK_KHR_performance_query" + +typedef enum VkPerformanceCounterUnitKHR { + VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0, + VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1, + VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2, + VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3, + VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4, + VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5, + VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6, + VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7, + VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8, + VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9, + VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10, + VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterUnitKHR; + +typedef enum VkPerformanceCounterScopeKHR { + VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0, + VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1, + VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2, + VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, + VK_QUERY_SCOPE_RENDER_PASS_KHR = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, + VK_QUERY_SCOPE_COMMAND_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR, + VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterScopeKHR; + +typedef enum VkPerformanceCounterStorageKHR { + VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0, + VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1, + VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2, + VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3, + VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4, + VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5, + VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterStorageKHR; + +// Flag bits for VkPerformanceCounterDescriptionFlagBitsKHR +typedef VkFlags VkPerformanceCounterDescriptionFlagBitsKHR; +#define VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR 0x00000001U +#define VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR 0x00000002U +#define VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR +#define VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR + +typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR; + +// Flag bits for VkAcquireProfilingLockFlagBitsKHR +typedef VkFlags VkAcquireProfilingLockFlagBitsKHR; + +typedef VkFlags VkAcquireProfilingLockFlagsKHR; +typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 performanceCounterQueryPools; + VkBool32 performanceCounterMultipleQueryPools; +} VkPhysicalDevicePerformanceQueryFeaturesKHR; + +typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 allowCommandBufferQueryCopies; +} VkPhysicalDevicePerformanceQueryPropertiesKHR; + +typedef struct VkPerformanceCounterKHR { + VkStructureType sType; + void* pNext; + VkPerformanceCounterUnitKHR unit; + VkPerformanceCounterScopeKHR scope; + VkPerformanceCounterStorageKHR storage; + uint8_t uuid[VK_UUID_SIZE]; +} VkPerformanceCounterKHR; + +typedef struct VkPerformanceCounterDescriptionKHR { + VkStructureType sType; + void* pNext; + VkPerformanceCounterDescriptionFlagsKHR flags; + char name[VK_MAX_DESCRIPTION_SIZE]; + char category[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; +} VkPerformanceCounterDescriptionKHR; + +typedef struct VkQueryPoolPerformanceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t queueFamilyIndex; + uint32_t counterIndexCount; + const uint32_t* pCounterIndices; +} VkQueryPoolPerformanceCreateInfoKHR; + +typedef union VkPerformanceCounterResultKHR { + int32_t int32; + int64_t int64; + uint32_t uint32; + uint64_t uint64; + float float32; + double float64; +} VkPerformanceCounterResultKHR; + +typedef struct VkAcquireProfilingLockInfoKHR { + VkStructureType sType; + const void* pNext; + VkAcquireProfilingLockFlagsKHR flags; + uint64_t timeout; +} VkAcquireProfilingLockInfoKHR; + +typedef struct VkPerformanceQuerySubmitInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t counterPassIndex; +} VkPerformanceQuerySubmitInfoKHR; + +typedef struct VkPerformanceQueryReservationInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t maxPerformanceQueriesPerPool; +} VkPerformanceQueryReservationInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkReleaseProfilingLockKHR)(VkDevice device); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + uint32_t* pCounterCount, + VkPerformanceCounterKHR* pCounters, + VkPerformanceCounterDescriptionKHR* pCounterDescriptions); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( + VkPhysicalDevice physicalDevice, + const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, + uint32_t* pNumPasses); + +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR( + VkDevice device, + const VkAcquireProfilingLockInfoKHR* pInfo); + +VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR( + VkDevice device); +#endif + + +#define VK_KHR_get_surface_capabilities2 1 +#define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1 +#define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2" +typedef struct VkPhysicalDeviceSurfaceInfo2KHR { + VkStructureType sType; + const void* pNext; + VkSurfaceKHR surface; +} VkPhysicalDeviceSurfaceInfo2KHR; + +typedef struct VkSurfaceCapabilities2KHR { + VkStructureType sType; + void* pNext; + VkSurfaceCapabilitiesKHR surfaceCapabilities; +} VkSurfaceCapabilities2KHR; + +typedef struct VkSurfaceFormat2KHR { + VkStructureType sType; + void* pNext; + VkSurfaceFormatKHR surfaceFormat; +} VkSurfaceFormat2KHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkSurfaceCapabilities2KHR* pSurfaceCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormat2KHR* pSurfaceFormats); +#endif + + +#define VK_KHR_get_display_properties2 1 +#define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1 +#define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2" +typedef struct VkDisplayProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPropertiesKHR displayProperties; +} VkDisplayProperties2KHR; + +typedef struct VkDisplayPlaneProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPlanePropertiesKHR displayPlaneProperties; +} VkDisplayPlaneProperties2KHR; + +typedef struct VkDisplayModeProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayModePropertiesKHR displayModeProperties; +} VkDisplayModeProperties2KHR; + +typedef struct VkDisplayPlaneInfo2KHR { + VkStructureType sType; + const void* pNext; + VkDisplayModeKHR mode; + uint32_t planeIndex; +} VkDisplayPlaneInfo2KHR; + +typedef struct VkDisplayPlaneCapabilities2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPlaneCapabilitiesKHR capabilities; +} VkDisplayPlaneCapabilities2KHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayProperties2KHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlaneProperties2KHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModeProperties2KHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR( + VkPhysicalDevice physicalDevice, + const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, + VkDisplayPlaneCapabilities2KHR* pCapabilities); +#endif + + +#define VK_KHR_shader_clock 1 +#define VK_KHR_SHADER_CLOCK_SPEC_VERSION 1 +#define VK_KHR_SHADER_CLOCK_EXTENSION_NAME "VK_KHR_shader_clock" +typedef struct VkPhysicalDeviceShaderClockFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderSubgroupClock; + VkBool32 shaderDeviceClock; +} VkPhysicalDeviceShaderClockFeaturesKHR; + + + +#define VK_KHR_swapchain_mutable_format 1 +#define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION 1 +#define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME "VK_KHR_swapchain_mutable_format" + + +#define VK_KHR_shader_terminate_invocation 1 +#define VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION 1 +#define VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME "VK_KHR_shader_terminate_invocation" +typedef struct VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderTerminateInvocation; +} VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR; + + + +#define VK_KHR_fragment_shading_rate 1 +#define VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION 2 +#define VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME "VK_KHR_fragment_shading_rate" + +typedef enum VkFragmentShadingRateCombinerOpKHR { + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR = 0, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR = 1, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR = 2, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR = 3, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR = 4, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_ENUM_KHR = 0x7FFFFFFF +} VkFragmentShadingRateCombinerOpKHR; +typedef struct VkFragmentShadingRateAttachmentInfoKHR { + VkStructureType sType; + const void* pNext; + const VkAttachmentReference2* pFragmentShadingRateAttachment; + VkExtent2D shadingRateAttachmentTexelSize; +} VkFragmentShadingRateAttachmentInfoKHR; + +typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkExtent2D fragmentSize; + VkFragmentShadingRateCombinerOpKHR combinerOps[2]; +} VkPipelineFragmentShadingRateStateCreateInfoKHR; + +typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 pipelineFragmentShadingRate; + VkBool32 primitiveFragmentShadingRate; + VkBool32 attachmentFragmentShadingRate; +} VkPhysicalDeviceFragmentShadingRateFeaturesKHR; + +typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR { + VkStructureType sType; + void* pNext; + VkExtent2D minFragmentShadingRateAttachmentTexelSize; + VkExtent2D maxFragmentShadingRateAttachmentTexelSize; + uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio; + VkBool32 primitiveFragmentShadingRateWithMultipleViewports; + VkBool32 layeredShadingRateAttachments; + VkBool32 fragmentShadingRateNonTrivialCombinerOps; + VkExtent2D maxFragmentSize; + uint32_t maxFragmentSizeAspectRatio; + uint32_t maxFragmentShadingRateCoverageSamples; + VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples; + VkBool32 fragmentShadingRateWithShaderDepthStencilWrites; + VkBool32 fragmentShadingRateWithSampleMask; + VkBool32 fragmentShadingRateWithShaderSampleMask; + VkBool32 fragmentShadingRateWithConservativeRasterization; + VkBool32 fragmentShadingRateWithFragmentShaderInterlock; + VkBool32 fragmentShadingRateWithCustomSampleLocations; + VkBool32 fragmentShadingRateStrictMultiplyCombiner; +} VkPhysicalDeviceFragmentShadingRatePropertiesKHR; + +typedef struct VkPhysicalDeviceFragmentShadingRateKHR { + VkStructureType sType; + void* pNext; + VkSampleCountFlags sampleCounts; + VkExtent2D fragmentSize; +} VkPhysicalDeviceFragmentShadingRateKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); +typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateKHR)(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceFragmentShadingRatesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pFragmentShadingRateCount, + VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR( + VkCommandBuffer commandBuffer, + const VkExtent2D* pFragmentSize, + const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); +#endif + + +#define VK_KHR_object_refresh 1 +#define VK_KHR_OBJECT_REFRESH_SPEC_VERSION 1 +#define VK_KHR_OBJECT_REFRESH_EXTENSION_NAME "VK_KHR_object_refresh" + +// Flag bits for VkRefreshObjectFlagBitsKHR +typedef VkFlags VkRefreshObjectFlagBitsKHR; + +typedef VkFlags VkRefreshObjectFlagsKHR; +typedef struct VkRefreshObjectKHR { + VkObjectType objectType; + uint64_t objectHandle; + VkRefreshObjectFlagsKHR flags; +} VkRefreshObjectKHR; + +typedef struct VkRefreshObjectListKHR { + VkStructureType sType; + const void* pNext; + uint32_t objectCount; + const VkRefreshObjectKHR* pObjects; +} VkRefreshObjectListKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdRefreshObjectsKHR)(VkCommandBuffer commandBuffer, const VkRefreshObjectListKHR* pRefreshObjects); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceRefreshableObjectTypesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pRefreshableObjectTypeCount, VkObjectType* pRefreshableObjectTypes); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdRefreshObjectsKHR( + VkCommandBuffer commandBuffer, + const VkRefreshObjectListKHR* pRefreshObjects); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceRefreshableObjectTypesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pRefreshableObjectTypeCount, + VkObjectType* pRefreshableObjectTypes); +#endif + + +#define VK_KHR_synchronization2 1 +typedef uint64_t VkFlags64; +#define VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION 1 +#define VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME "VK_KHR_synchronization2" +typedef VkFlags64 VkPipelineStageFlags2KHR; + +// Flag bits for VkPipelineStageFlagBits2KHR +typedef VkFlags64 VkPipelineStageFlagBits2KHR; +#define VK_PIPELINE_STAGE_2_NONE_KHR 0ULL +#define VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR 0x00000001ULL +#define VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR 0x00000002ULL +#define VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR 0x00000004ULL +#define VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR 0x00000008ULL +#define VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR 0x00000010ULL +#define VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR 0x00000020ULL +#define VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR 0x00000040ULL +#define VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR 0x00000080ULL +#define VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR 0x00000100ULL +#define VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR 0x00000200ULL +#define VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR 0x00000400ULL +#define VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR 0x00000800ULL +#define VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR 0x00001000ULL +#define VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR 0x00002000ULL +#define VK_PIPELINE_STAGE_2_HOST_BIT_KHR 0x00004000ULL +#define VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR 0x00008000ULL +#define VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR 0x00010000ULL +#define VK_PIPELINE_STAGE_2_COPY_BIT_KHR 0x100000000ULL +#define VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR 0x200000000ULL +#define VK_PIPELINE_STAGE_2_BLIT_BIT_KHR 0x400000000ULL +#define VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR 0x800000000ULL +#define VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR 0x1000000000ULL +#define VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR 0x2000000000ULL +#define VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR 0x4000000000ULL +#define VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT 0x01000000ULL +#define VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT 0x00040000ULL +#define VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV 0x00020000ULL +#define VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR 0x00400000ULL +#define VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR 0x02000000ULL +#define VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR 0x00200000ULL +#define VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT 0x00800000ULL +#define VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV 0x00080000ULL +#define VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV 0x00100000ULL +#define VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR +#define VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR +#define VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR +#define VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR + +typedef VkFlags64 VkAccessFlags2KHR; + +// Flag bits for VkAccessFlagBits2KHR +typedef VkFlags64 VkAccessFlagBits2KHR; +#define VK_ACCESS_2_NONE_KHR 0ULL +#define VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR 0x00000001ULL +#define VK_ACCESS_2_INDEX_READ_BIT_KHR 0x00000002ULL +#define VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR 0x00000004ULL +#define VK_ACCESS_2_UNIFORM_READ_BIT_KHR 0x00000008ULL +#define VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR 0x00000010ULL +#define VK_ACCESS_2_SHADER_READ_BIT_KHR 0x00000020ULL +#define VK_ACCESS_2_SHADER_WRITE_BIT_KHR 0x00000040ULL +#define VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR 0x00000080ULL +#define VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR 0x00000100ULL +#define VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR 0x00000200ULL +#define VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR 0x00000400ULL +#define VK_ACCESS_2_TRANSFER_READ_BIT_KHR 0x00000800ULL +#define VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR 0x00001000ULL +#define VK_ACCESS_2_HOST_READ_BIT_KHR 0x00002000ULL +#define VK_ACCESS_2_HOST_WRITE_BIT_KHR 0x00004000ULL +#define VK_ACCESS_2_MEMORY_READ_BIT_KHR 0x00008000ULL +#define VK_ACCESS_2_MEMORY_WRITE_BIT_KHR 0x00010000ULL +#define VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR 0x100000000ULL +#define VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR 0x200000000ULL +#define VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR 0x400000000ULL +#define VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT 0x02000000ULL +#define VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT 0x04000000ULL +#define VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT 0x08000000ULL +#define VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT 0x00100000ULL +#define VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV 0x00020000ULL +#define VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV 0x00040000ULL +#define VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR 0x00800000ULL +#define VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR 0x00200000ULL +#define VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR 0x00400000ULL +#define VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT 0x01000000ULL +#define VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT 0x00080000ULL +#define VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR +#define VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR +#define VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR + + +// Flag bits for VkSubmitFlagBitsKHR +typedef VkFlags VkSubmitFlagBitsKHR; +#define VK_SUBMIT_PROTECTED_BIT_KHR 0x00000001U + +typedef VkFlags VkSubmitFlagsKHR; +typedef struct VkMemoryBarrier2KHR { + VkStructureType sType; + const void* pNext; + VkPipelineStageFlags2KHR srcStageMask; + VkAccessFlags2KHR srcAccessMask; + VkPipelineStageFlags2KHR dstStageMask; + VkAccessFlags2KHR dstAccessMask; +} VkMemoryBarrier2KHR; + +typedef struct VkBufferMemoryBarrier2KHR { + VkStructureType sType; + const void* pNext; + VkPipelineStageFlags2KHR srcStageMask; + VkAccessFlags2KHR srcAccessMask; + VkPipelineStageFlags2KHR dstStageMask; + VkAccessFlags2KHR dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} VkBufferMemoryBarrier2KHR; + +typedef struct VkImageMemoryBarrier2KHR { + VkStructureType sType; + const void* pNext; + VkPipelineStageFlags2KHR srcStageMask; + VkAccessFlags2KHR srcAccessMask; + VkPipelineStageFlags2KHR dstStageMask; + VkAccessFlags2KHR dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} VkImageMemoryBarrier2KHR; + +typedef struct VkDependencyInfoKHR { + VkStructureType sType; + const void* pNext; + VkDependencyFlags dependencyFlags; + uint32_t memoryBarrierCount; + const VkMemoryBarrier2KHR* pMemoryBarriers; + uint32_t bufferMemoryBarrierCount; + const VkBufferMemoryBarrier2KHR* pBufferMemoryBarriers; + uint32_t imageMemoryBarrierCount; + const VkImageMemoryBarrier2KHR* pImageMemoryBarriers; +} VkDependencyInfoKHR; + +typedef struct VkSemaphoreSubmitInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + uint64_t value; + VkPipelineStageFlags2KHR stageMask; + uint32_t deviceIndex; +} VkSemaphoreSubmitInfoKHR; + +typedef struct VkCommandBufferSubmitInfoKHR { + VkStructureType sType; + const void* pNext; + VkCommandBuffer commandBuffer; + uint32_t deviceMask; +} VkCommandBufferSubmitInfoKHR; + +typedef struct VkSubmitInfo2KHR { + VkStructureType sType; + const void* pNext; + VkSubmitFlagsKHR flags; + uint32_t waitSemaphoreInfoCount; + const VkSemaphoreSubmitInfoKHR* pWaitSemaphoreInfos; + uint32_t commandBufferInfoCount; + const VkCommandBufferSubmitInfoKHR* pCommandBufferInfos; + uint32_t signalSemaphoreInfoCount; + const VkSemaphoreSubmitInfoKHR* pSignalSemaphoreInfos; +} VkSubmitInfo2KHR; + +typedef struct VkPhysicalDeviceSynchronization2FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 synchronization2; +} VkPhysicalDeviceSynchronization2FeaturesKHR; + +typedef struct VkQueueFamilyCheckpointProperties2NV { + VkStructureType sType; + void* pNext; + VkPipelineStageFlags2KHR checkpointExecutionStageMask; +} VkQueueFamilyCheckpointProperties2NV; + +typedef struct VkCheckpointData2NV { + VkStructureType sType; + void* pNext; + VkPipelineStageFlags2KHR stage; + void* pCheckpointMarker; +} VkCheckpointData2NV; + +typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfoKHR* pDependencyInfo); +typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2KHR stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents2KHR)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfoKHR* pDependencyInfos); +typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer commandBuffer, const VkDependencyInfoKHR* pDependencyInfo); +typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkQueryPool queryPool, uint32_t query); +typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2KHR)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2KHR* pSubmits, VkFence fence); +typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); +typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointData2NV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2KHR( + VkCommandBuffer commandBuffer, + VkEvent event, + const VkDependencyInfoKHR* pDependencyInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2KHR( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags2KHR stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2KHR( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + const VkDependencyInfoKHR* pDependencyInfos); + +VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2KHR( + VkCommandBuffer commandBuffer, + const VkDependencyInfoKHR* pDependencyInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2KHR( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2KHR stage, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo2KHR* pSubmits, + VkFence fence); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarker2AMD( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2KHR stage, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + uint32_t marker); + +VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV( + VkQueue queue, + uint32_t* pCheckpointDataCount, + VkCheckpointData2NV* pCheckpointData); +#endif + + +#define VK_KHR_copy_commands2 1 +#define VK_KHR_COPY_COMMANDS_2_SPEC_VERSION 1 +#define VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME "VK_KHR_copy_commands2" +typedef struct VkBufferCopy2KHR { + VkStructureType sType; + const void* pNext; + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; +} VkBufferCopy2KHR; + +typedef struct VkCopyBufferInfo2KHR { + VkStructureType sType; + const void* pNext; + VkBuffer srcBuffer; + VkBuffer dstBuffer; + uint32_t regionCount; + const VkBufferCopy2KHR* pRegions; +} VkCopyBufferInfo2KHR; + +typedef struct VkImageCopy2KHR { + VkStructureType sType; + const void* pNext; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageCopy2KHR; + +typedef struct VkCopyImageInfo2KHR { + VkStructureType sType; + const void* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkImageCopy2KHR* pRegions; +} VkCopyImageInfo2KHR; + +typedef struct VkBufferImageCopy2KHR { + VkStructureType sType; + const void* pNext; + VkDeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy2KHR; + +typedef struct VkCopyBufferToImageInfo2KHR { + VkStructureType sType; + const void* pNext; + VkBuffer srcBuffer; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkBufferImageCopy2KHR* pRegions; +} VkCopyBufferToImageInfo2KHR; + +typedef struct VkCopyImageToBufferInfo2KHR { + VkStructureType sType; + const void* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkBuffer dstBuffer; + uint32_t regionCount; + const VkBufferImageCopy2KHR* pRegions; +} VkCopyImageToBufferInfo2KHR; + +typedef struct VkImageBlit2KHR { + VkStructureType sType; + const void* pNext; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffsets[2]; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffsets[2]; +} VkImageBlit2KHR; + +typedef struct VkBlitImageInfo2KHR { + VkStructureType sType; + const void* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkImageBlit2KHR* pRegions; + VkFilter filter; +} VkBlitImageInfo2KHR; + +typedef struct VkImageResolve2KHR { + VkStructureType sType; + const void* pNext; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageResolve2KHR; + +typedef struct VkResolveImageInfo2KHR { + VkStructureType sType; + const void* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkImageResolve2KHR* pRegions; +} VkResolveImageInfo2KHR; + +typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR* pCopyBufferInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR* pCopyImageInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBlitImage2KHR)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR* pBlitImageInfo); +typedef void (VKAPI_PTR *PFN_vkCmdResolveImage2KHR)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR* pResolveImageInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2KHR( + VkCommandBuffer commandBuffer, + const VkCopyBufferInfo2KHR* pCopyBufferInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2KHR( + VkCommandBuffer commandBuffer, + const VkCopyImageInfo2KHR* pCopyImageInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2KHR( + VkCommandBuffer commandBuffer, + const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2KHR( + VkCommandBuffer commandBuffer, + const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2KHR( + VkCommandBuffer commandBuffer, + const VkBlitImageInfo2KHR* pBlitImageInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR( + VkCommandBuffer commandBuffer, + const VkResolveImageInfo2KHR* pResolveImageInfo); +#endif + + +#define VK_EXT_depth_range_unrestricted 1 +#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1 +#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted" + + +#define VK_EXT_texture_compression_astc_hdr 1 +#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION 1 +#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME "VK_EXT_texture_compression_astc_hdr" +typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 textureCompressionASTC_HDR; +} VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT; + + + +#define VK_EXT_astc_decode_mode 1 +#define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1 +#define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode" +typedef struct VkImageViewASTCDecodeModeEXT { + VkStructureType sType; + const void* pNext; + VkFormat decodeMode; +} VkImageViewASTCDecodeModeEXT; + +typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 decodeModeSharedExponent; +} VkPhysicalDeviceASTCDecodeFeaturesEXT; + + + +#define VK_EXT_direct_mode_display 1 +#define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1 +#define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display" +typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display); +#endif + + +#define VK_EXT_display_surface_counter 1 +#define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1 +#define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter" + +// Flag bits for VkSurfaceCounterFlagBitsEXT +typedef VkFlags VkSurfaceCounterFlagBitsEXT; +#define VK_SURFACE_COUNTER_VBLANK_BIT_EXT 0x00000001U +#define VK_SURFACE_COUNTER_VBLANK_EXT VK_SURFACE_COUNTER_VBLANK_BIT_EXT + +typedef VkFlags VkSurfaceCounterFlagsEXT; +typedef struct VkSurfaceCapabilities2EXT { + VkStructureType sType; + void* pNext; + uint32_t minImageCount; + uint32_t maxImageCount; + VkExtent2D currentExtent; + VkExtent2D minImageExtent; + VkExtent2D maxImageExtent; + uint32_t maxImageArrayLayers; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkSurfaceTransformFlagBitsKHR currentTransform; + VkCompositeAlphaFlagsKHR supportedCompositeAlpha; + VkImageUsageFlags supportedUsageFlags; + VkSurfaceCounterFlagsEXT supportedSurfaceCounters; +} VkSurfaceCapabilities2EXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilities2EXT* pSurfaceCapabilities); +#endif + + +#define VK_EXT_display_control 1 +#define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1 +#define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control" + +typedef enum VkDisplayPowerStateEXT { + VK_DISPLAY_POWER_STATE_OFF_EXT = 0, + VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1, + VK_DISPLAY_POWER_STATE_ON_EXT = 2, + VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDisplayPowerStateEXT; + +typedef enum VkDeviceEventTypeEXT { + VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0, + VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceEventTypeEXT; + +typedef enum VkDisplayEventTypeEXT { + VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0, + VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDisplayEventTypeEXT; +typedef struct VkDisplayPowerInfoEXT { + VkStructureType sType; + const void* pNext; + VkDisplayPowerStateEXT powerState; +} VkDisplayPowerInfoEXT; + +typedef struct VkDeviceEventInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceEventTypeEXT deviceEvent; +} VkDeviceEventInfoEXT; + +typedef struct VkDisplayEventInfoEXT { + VkStructureType sType; + const void* pNext; + VkDisplayEventTypeEXT displayEvent; +} VkDisplayEventInfoEXT; + +typedef struct VkSwapchainCounterCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkSurfaceCounterFlagsEXT surfaceCounters; +} VkSwapchainCounterCreateInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo); +typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT( + VkDevice device, + VkDisplayKHR display, + const VkDisplayPowerInfoEXT* pDisplayPowerInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT( + VkDevice device, + const VkDeviceEventInfoEXT* pDeviceEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT( + VkDevice device, + VkDisplayKHR display, + const VkDisplayEventInfoEXT* pDisplayEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT( + VkDevice device, + VkSwapchainKHR swapchain, + VkSurfaceCounterFlagBitsEXT counter, + uint64_t* pCounterValue); +#endif + + +#define VK_EXT_discard_rectangles 1 +#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1 +#define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles" + +typedef enum VkDiscardRectangleModeEXT { + VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0, + VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1, + VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDiscardRectangleModeEXT; +typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; +typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxDiscardRectangles; +} VkPhysicalDeviceDiscardRectanglePropertiesEXT; + +typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineDiscardRectangleStateCreateFlagsEXT flags; + VkDiscardRectangleModeEXT discardRectangleMode; + uint32_t discardRectangleCount; + const VkRect2D* pDiscardRectangles; +} VkPipelineDiscardRectangleStateCreateInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT( + VkCommandBuffer commandBuffer, + uint32_t firstDiscardRectangle, + uint32_t discardRectangleCount, + const VkRect2D* pDiscardRectangles); +#endif + + +#define VK_EXT_conservative_rasterization 1 +#define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1 +#define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization" + +typedef enum VkConservativeRasterizationModeEXT { + VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0, + VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1, + VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2, + VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkConservativeRasterizationModeEXT; +typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT; +typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT { + VkStructureType sType; + void* pNext; + float primitiveOverestimationSize; + float maxExtraPrimitiveOverestimationSize; + float extraPrimitiveOverestimationSizeGranularity; + VkBool32 primitiveUnderestimation; + VkBool32 conservativePointAndLineRasterization; + VkBool32 degenerateTrianglesRasterized; + VkBool32 degenerateLinesRasterized; + VkBool32 fullyCoveredFragmentShaderInputVariable; + VkBool32 conservativeRasterizationPostDepthCoverage; +} VkPhysicalDeviceConservativeRasterizationPropertiesEXT; + +typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationConservativeStateCreateFlagsEXT flags; + VkConservativeRasterizationModeEXT conservativeRasterizationMode; + float extraPrimitiveOverestimationSize; +} VkPipelineRasterizationConservativeStateCreateInfoEXT; + + + +#define VK_EXT_depth_clip_enable 1 +#define VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION 1 +#define VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME "VK_EXT_depth_clip_enable" +typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT; +typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 depthClipEnable; +} VkPhysicalDeviceDepthClipEnableFeaturesEXT; + +typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags; + VkBool32 depthClipEnable; +} VkPipelineRasterizationDepthClipStateCreateInfoEXT; + + + +#define VK_EXT_swapchain_colorspace 1 +#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 4 +#define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace" + + +#define VK_EXT_hdr_metadata 1 +#define VK_EXT_HDR_METADATA_SPEC_VERSION 2 +#define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata" +typedef struct VkXYColorEXT { + float x; + float y; +} VkXYColorEXT; + +typedef struct VkHdrMetadataEXT { + VkStructureType sType; + const void* pNext; + VkXYColorEXT displayPrimaryRed; + VkXYColorEXT displayPrimaryGreen; + VkXYColorEXT displayPrimaryBlue; + VkXYColorEXT whitePoint; + float maxLuminance; + float minLuminance; + float maxContentLightLevel; + float maxFrameAverageLightLevel; +} VkHdrMetadataEXT; + +typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT( + VkDevice device, + uint32_t swapchainCount, + const VkSwapchainKHR* pSwapchains, + const VkHdrMetadataEXT* pMetadata); +#endif + + +#define VK_EXT_external_memory_dma_buf 1 +#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1 +#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf" + + +#define VK_EXT_queue_family_foreign 1 +#define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1 +#define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign" +#define VK_QUEUE_FAMILY_FOREIGN_EXT (~2U) + + +#define VK_EXT_debug_utils 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT) +#define VK_EXT_DEBUG_UTILS_SPEC_VERSION 2 +#define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils" +typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT; + +// Flag bits for VkDebugUtilsMessageSeverityFlagBitsEXT +typedef VkFlags VkDebugUtilsMessageSeverityFlagBitsEXT; +#define VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT 0x00000001U +#define VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT 0x00000010U +#define VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT 0x00000100U +#define VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT 0x00001000U + + +// Flag bits for VkDebugUtilsMessageTypeFlagBitsEXT +typedef VkFlags VkDebugUtilsMessageTypeFlagBitsEXT; +#define VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT 0x00000001U +#define VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT 0x00000002U +#define VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT 0x00000004U + +typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT; +typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT; +typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT; +typedef struct VkDebugUtilsLabelEXT { + VkStructureType sType; + const void* pNext; + const char* pLabelName; + float color[4]; +} VkDebugUtilsLabelEXT; + +typedef struct VkDebugUtilsObjectNameInfoEXT { + VkStructureType sType; + const void* pNext; + VkObjectType objectType; + uint64_t objectHandle; + const char* pObjectName; +} VkDebugUtilsObjectNameInfoEXT; + +typedef struct VkDebugUtilsMessengerCallbackDataEXT { + VkStructureType sType; + const void* pNext; + VkDebugUtilsMessengerCallbackDataFlagsEXT flags; + const char* pMessageIdName; + int32_t messageIdNumber; + const char* pMessage; + uint32_t queueLabelCount; + const VkDebugUtilsLabelEXT* pQueueLabels; + uint32_t cmdBufLabelCount; + const VkDebugUtilsLabelEXT* pCmdBufLabels; + uint32_t objectCount; + const VkDebugUtilsObjectNameInfoEXT* pObjects; +} VkDebugUtilsMessengerCallbackDataEXT; + +typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)( + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, + void* pUserData); + +typedef struct VkDebugUtilsMessengerCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugUtilsMessengerCreateFlagsEXT flags; + VkDebugUtilsMessageSeverityFlagsEXT messageSeverity; + VkDebugUtilsMessageTypeFlagsEXT messageType; + PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback; + void* pUserData; +} VkDebugUtilsMessengerCreateInfoEXT; + +typedef struct VkDebugUtilsObjectTagInfoEXT { + VkStructureType sType; + const void* pNext; + VkObjectType objectType; + uint64_t objectHandle; + uint64_t tagName; + size_t tagSize; + const void* pTag; +} VkDebugUtilsObjectTagInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo); +typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo); +typedef void (VKAPI_PTR *PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void (VKAPI_PTR *PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue); +typedef void (VKAPI_PTR *PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger); +typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT( + VkDevice device, + const VkDebugUtilsObjectNameInfoEXT* pNameInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT( + VkDevice device, + const VkDebugUtilsObjectTagInfoEXT* pTagInfo); + +VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT( + VkQueue queue, + const VkDebugUtilsLabelEXT* pLabelInfo); + +VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT( + VkQueue queue); + +VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT( + VkQueue queue, + const VkDebugUtilsLabelEXT* pLabelInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT( + VkInstance instance, + const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugUtilsMessengerEXT* pMessenger); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT( + VkInstance instance, + VkDebugUtilsMessengerEXT messenger, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT( + VkInstance instance, + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); +#endif + + +#define VK_EXT_shader_stencil_export 1 +#define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1 +#define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export" + + +#define VK_EXT_sample_locations 1 +#define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1 +#define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations" +typedef struct VkSampleLocationEXT { + float x; + float y; +} VkSampleLocationEXT; + +typedef struct VkSampleLocationsInfoEXT { + VkStructureType sType; + const void* pNext; + VkSampleCountFlagBits sampleLocationsPerPixel; + VkExtent2D sampleLocationGridSize; + uint32_t sampleLocationsCount; + const VkSampleLocationEXT* pSampleLocations; +} VkSampleLocationsInfoEXT; + +typedef struct VkAttachmentSampleLocationsEXT { + uint32_t attachmentIndex; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkAttachmentSampleLocationsEXT; + +typedef struct VkSubpassSampleLocationsEXT { + uint32_t subpassIndex; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkSubpassSampleLocationsEXT; + +typedef struct VkRenderPassSampleLocationsBeginInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t attachmentInitialSampleLocationsCount; + const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; + uint32_t postSubpassSampleLocationsCount; + const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations; +} VkRenderPassSampleLocationsBeginInfoEXT; + +typedef struct VkPipelineSampleLocationsStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 sampleLocationsEnable; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkPipelineSampleLocationsStateCreateInfoEXT; + +typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT { + VkStructureType sType; + void* pNext; + VkSampleCountFlags sampleLocationSampleCounts; + VkExtent2D maxSampleLocationGridSize; + float sampleLocationCoordinateRange[2]; + uint32_t sampleLocationSubPixelBits; + VkBool32 variableSampleLocations; +} VkPhysicalDeviceSampleLocationsPropertiesEXT; + +typedef struct VkMultisamplePropertiesEXT { + VkStructureType sType; + void* pNext; + VkExtent2D maxSampleLocationGridSize; +} VkMultisamplePropertiesEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT( + VkCommandBuffer commandBuffer, + const VkSampleLocationsInfoEXT* pSampleLocationsInfo); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT( + VkPhysicalDevice physicalDevice, + VkSampleCountFlagBits samples, + VkMultisamplePropertiesEXT* pMultisampleProperties); +#endif + + +#define VK_EXT_blend_operation_advanced 1 +#define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2 +#define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced" + +typedef enum VkBlendOverlapEXT { + VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0, + VK_BLEND_OVERLAP_DISJOINT_EXT = 1, + VK_BLEND_OVERLAP_CONJOINT_EXT = 2, + VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF +} VkBlendOverlapEXT; +typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 advancedBlendCoherentOperations; +} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; + +typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t advancedBlendMaxColorAttachments; + VkBool32 advancedBlendIndependentBlend; + VkBool32 advancedBlendNonPremultipliedSrcColor; + VkBool32 advancedBlendNonPremultipliedDstColor; + VkBool32 advancedBlendCorrelatedOverlap; + VkBool32 advancedBlendAllOperations; +} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; + +typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 srcPremultiplied; + VkBool32 dstPremultiplied; + VkBlendOverlapEXT blendOverlap; +} VkPipelineColorBlendAdvancedStateCreateInfoEXT; + + + +#define VK_EXT_post_depth_coverage 1 +#define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1 +#define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage" + + +#define VK_EXT_image_drm_format_modifier 1 +#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 2 +#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME "VK_EXT_image_drm_format_modifier" +typedef VkFlags64 VkFormatFeatureFlags2KHR; + +// Flag bits for VkFormatFeatureFlagBits2KHR +typedef VkFlags64 VkFormatFeatureFlagBits2KHR; +#define VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR 0x00000001ULL +#define VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR 0x00000002ULL +#define VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR 0x00000004ULL +#define VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR 0x00000008ULL +#define VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR 0x00000010ULL +#define VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR 0x00000020ULL +#define VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR 0x00000040ULL +#define VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR 0x00000080ULL +#define VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR 0x00000100ULL +#define VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR 0x00000200ULL +#define VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR 0x00000400ULL +#define VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR 0x00000800ULL +#define VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR 0x00001000ULL +#define VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT 0x00002000ULL +#define VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR 0x00004000ULL +#define VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR 0x00008000ULL +#define VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR 0x00010000ULL +#define VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR 0x00020000ULL +#define VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR 0x00040000ULL +#define VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR 0x00080000ULL +#define VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR 0x00100000ULL +#define VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR 0x00200000ULL +#define VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR 0x00400000ULL +#define VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR 0x00800000ULL +#define VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR 0x80000000ULL +#define VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR 0x100000000ULL +#define VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR 0x200000000ULL +#define VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR 0x40000000ULL + +typedef struct VkDrmFormatModifierPropertiesEXT { + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + VkFormatFeatureFlags drmFormatModifierTilingFeatures; +} VkDrmFormatModifierPropertiesEXT; + +typedef struct VkDrmFormatModifierPropertiesListEXT { + VkStructureType sType; + void* pNext; + uint32_t drmFormatModifierCount; + VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties; +} VkDrmFormatModifierPropertiesListEXT; + +typedef struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT { + VkStructureType sType; + const void* pNext; + uint64_t drmFormatModifier; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; +} VkPhysicalDeviceImageDrmFormatModifierInfoEXT; + +typedef struct VkImageDrmFormatModifierListCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t drmFormatModifierCount; + const uint64_t* pDrmFormatModifiers; +} VkImageDrmFormatModifierListCreateInfoEXT; + +typedef struct VkImageDrmFormatModifierExplicitCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + const VkSubresourceLayout* pPlaneLayouts; +} VkImageDrmFormatModifierExplicitCreateInfoEXT; + +typedef struct VkImageDrmFormatModifierPropertiesEXT { + VkStructureType sType; + void* pNext; + uint64_t drmFormatModifier; +} VkImageDrmFormatModifierPropertiesEXT; + +typedef struct VkDrmFormatModifierProperties2EXT { + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + VkFormatFeatureFlags2KHR drmFormatModifierTilingFeatures; +} VkDrmFormatModifierProperties2EXT; + +typedef struct VkDrmFormatModifierPropertiesList2EXT { + VkStructureType sType; + void* pNext; + uint32_t drmFormatModifierCount; + VkDrmFormatModifierProperties2EXT* pDrmFormatModifierProperties; +} VkDrmFormatModifierPropertiesList2EXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT( + VkDevice device, + VkImage image, + VkImageDrmFormatModifierPropertiesEXT* pProperties); +#endif + + +#define VK_EXT_filter_cubic 1 +#define VK_EXT_FILTER_CUBIC_SPEC_VERSION 3 +#define VK_EXT_FILTER_CUBIC_EXTENSION_NAME "VK_EXT_filter_cubic" +typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT { + VkStructureType sType; + void* pNext; + VkImageViewType imageViewType; +} VkPhysicalDeviceImageViewImageFormatInfoEXT; + +typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 filterCubic; + VkBool32 filterCubicMinmax; +} VkFilterCubicImageViewImageFormatPropertiesEXT; + + + +#define VK_EXT_global_priority 1 +#define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2 +#define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority" + +typedef enum VkQueueGlobalPriorityEXT { + VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128, + VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256, + VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512, + VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024, + VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_EXT = 0x7FFFFFFF +} VkQueueGlobalPriorityEXT; +typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkQueueGlobalPriorityEXT globalPriority; +} VkDeviceQueueGlobalPriorityCreateInfoEXT; + + + +#define VK_EXT_external_memory_host 1 +#define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1 +#define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host" +typedef struct VkImportMemoryHostPointerInfoEXT { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + void* pHostPointer; +} VkImportMemoryHostPointerInfoEXT; + +typedef struct VkMemoryHostPointerPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryHostPointerPropertiesEXT; + +typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize minImportedHostPointerAlignment; +} VkPhysicalDeviceExternalMemoryHostPropertiesEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + const void* pHostPointer, + VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); +#endif + + +#define VK_EXT_calibrated_timestamps 1 +#define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 2 +#define VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_EXT_calibrated_timestamps" + +typedef enum VkTimeDomainEXT { + VK_TIME_DOMAIN_DEVICE_EXT = 0, + VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1, + VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2, + VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3, + VK_TIME_DOMAIN_MAX_ENUM_EXT = 0x7FFFFFFF +} VkTimeDomainEXT; +typedef struct VkCalibratedTimestampInfoEXT { + VkStructureType sType; + const void* pNext; + VkTimeDomainEXT timeDomain; +} VkCalibratedTimestampInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains); +typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( + VkPhysicalDevice physicalDevice, + uint32_t* pTimeDomainCount, + VkTimeDomainEXT* pTimeDomains); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT( + VkDevice device, + uint32_t timestampCount, + const VkCalibratedTimestampInfoEXT* pTimestampInfos, + uint64_t* pTimestamps, + uint64_t* pMaxDeviation); +#endif + + +#define VK_EXT_vertex_attribute_divisor 1 +#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 3 +#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor" +typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxVertexAttribDivisor; +} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; + +typedef struct VkVertexInputBindingDivisorDescriptionEXT { + uint32_t binding; + uint32_t divisor; +} VkVertexInputBindingDivisorDescriptionEXT; + +typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t vertexBindingDivisorCount; + const VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors; +} VkPipelineVertexInputDivisorStateCreateInfoEXT; + +typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 vertexAttributeInstanceRateDivisor; + VkBool32 vertexAttributeInstanceRateZeroDivisor; +} VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT; + + + +#define VK_EXT_pci_bus_info 1 +#define VK_EXT_PCI_BUS_INFO_SPEC_VERSION 2 +#define VK_EXT_PCI_BUS_INFO_EXTENSION_NAME "VK_EXT_pci_bus_info" +typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t pciDomain; + uint32_t pciBus; + uint32_t pciDevice; + uint32_t pciFunction; +} VkPhysicalDevicePCIBusInfoPropertiesEXT; + + + +#define VK_EXT_subgroup_size_control 1 +#define VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION 2 +#define VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME "VK_EXT_subgroup_size_control" +typedef struct VkPhysicalDeviceSubgroupSizeControlFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 subgroupSizeControl; + VkBool32 computeFullSubgroups; +} VkPhysicalDeviceSubgroupSizeControlFeaturesEXT; + +typedef struct VkPhysicalDeviceSubgroupSizeControlPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t minSubgroupSize; + uint32_t maxSubgroupSize; + uint32_t maxComputeWorkgroupSubgroups; + VkShaderStageFlags requiredSubgroupSizeStages; +} VkPhysicalDeviceSubgroupSizeControlPropertiesEXT; + +typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT { + VkStructureType sType; + void* pNext; + uint32_t requiredSubgroupSize; +} VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT; + + + +#define VK_EXT_shader_image_atomic_int64 1 +#define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION 1 +#define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME "VK_EXT_shader_image_atomic_int64" +typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderImageInt64Atomics; + VkBool32 sparseImageInt64Atomics; +} VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT; + + + +#define VK_EXT_memory_budget 1 +#define VK_EXT_MEMORY_BUDGET_SPEC_VERSION 1 +#define VK_EXT_MEMORY_BUDGET_EXTENSION_NAME "VK_EXT_memory_budget" +typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize heapBudget[VK_MAX_MEMORY_HEAPS]; + VkDeviceSize heapUsage[VK_MAX_MEMORY_HEAPS]; +} VkPhysicalDeviceMemoryBudgetPropertiesEXT; + + + +#define VK_EXT_validation_features 1 +#define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 5 +#define VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME "VK_EXT_validation_features" + +typedef enum VkValidationFeatureEnableEXT { + VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0, + VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1, + VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2, + VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT = 3, + VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT = 4, + VK_VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationFeatureEnableEXT; + +typedef enum VkValidationFeatureDisableEXT { + VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0, + VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1, + VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2, + VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3, + VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4, + VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5, + VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6, + VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT = 7, + VK_VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationFeatureDisableEXT; +typedef struct VkValidationFeaturesEXT { + VkStructureType sType; + const void* pNext; + uint32_t enabledValidationFeatureCount; + const VkValidationFeatureEnableEXT* pEnabledValidationFeatures; + uint32_t disabledValidationFeatureCount; + const VkValidationFeatureDisableEXT* pDisabledValidationFeatures; +} VkValidationFeaturesEXT; + + + +#define VK_EXT_fragment_shader_interlock 1 +#define VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION 1 +#define VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME "VK_EXT_fragment_shader_interlock" +typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 fragmentShaderSampleInterlock; + VkBool32 fragmentShaderPixelInterlock; + VkBool32 fragmentShaderShadingRateInterlock; +} VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT; + + + +#define VK_EXT_ycbcr_image_arrays 1 +#define VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION 1 +#define VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME "VK_EXT_ycbcr_image_arrays" +typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 ycbcrImageArrays; +} VkPhysicalDeviceYcbcrImageArraysFeaturesEXT; + + + +#define VK_EXT_headless_surface 1 +#define VK_EXT_HEADLESS_SURFACE_SPEC_VERSION 1 +#define VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME "VK_EXT_headless_surface" +typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT; +typedef struct VkHeadlessSurfaceCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkHeadlessSurfaceCreateFlagsEXT flags; +} VkHeadlessSurfaceCreateInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT( + VkInstance instance, + const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + + +#define VK_EXT_line_rasterization 1 +#define VK_EXT_LINE_RASTERIZATION_SPEC_VERSION 1 +#define VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME "VK_EXT_line_rasterization" + +typedef enum VkLineRasterizationModeEXT { + VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1, + VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3, + VK_LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkLineRasterizationModeEXT; +typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 rectangularLines; + VkBool32 bresenhamLines; + VkBool32 smoothLines; + VkBool32 stippledRectangularLines; + VkBool32 stippledBresenhamLines; + VkBool32 stippledSmoothLines; +} VkPhysicalDeviceLineRasterizationFeaturesEXT; + +typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t lineSubPixelPrecisionBits; +} VkPhysicalDeviceLineRasterizationPropertiesEXT; + +typedef struct VkPipelineRasterizationLineStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkLineRasterizationModeEXT lineRasterizationMode; + VkBool32 stippledLineEnable; + uint32_t lineStippleFactor; + uint16_t lineStipplePattern; +} VkPipelineRasterizationLineStateCreateInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT( + VkCommandBuffer commandBuffer, + uint32_t lineStippleFactor, + uint16_t lineStipplePattern); +#endif + + +#define VK_EXT_shader_atomic_float 1 +#define VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION 1 +#define VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME "VK_EXT_shader_atomic_float" +typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderBufferFloat32Atomics; + VkBool32 shaderBufferFloat32AtomicAdd; + VkBool32 shaderBufferFloat64Atomics; + VkBool32 shaderBufferFloat64AtomicAdd; + VkBool32 shaderSharedFloat32Atomics; + VkBool32 shaderSharedFloat32AtomicAdd; + VkBool32 shaderSharedFloat64Atomics; + VkBool32 shaderSharedFloat64AtomicAdd; + VkBool32 shaderImageFloat32Atomics; + VkBool32 shaderImageFloat32AtomicAdd; + VkBool32 sparseImageFloat32Atomics; + VkBool32 sparseImageFloat32AtomicAdd; +} VkPhysicalDeviceShaderAtomicFloatFeaturesEXT; + + + +#define VK_EXT_index_type_uint8 1 +#define VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION 1 +#define VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_EXT_index_type_uint8" +typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 indexTypeUint8; +} VkPhysicalDeviceIndexTypeUint8FeaturesEXT; + + + +#define VK_EXT_extended_dynamic_state 1 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION 1 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_extended_dynamic_state" +typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 extendedDynamicState; +} VkPhysicalDeviceExtendedDynamicStateFeaturesEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetCullModeEXT)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); +typedef void (VKAPI_PTR *PFN_vkCmdSetFrontFaceEXT)(VkCommandBuffer commandBuffer, VkFrontFace frontFace); +typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveTopologyEXT)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); +typedef void (VKAPI_PTR *PFN_vkCmdSetScissorWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); +typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers2EXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthCompareOpEXT)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilOpEXT)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetCullModeEXT( + VkCommandBuffer commandBuffer, + VkCullModeFlags cullMode); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFaceEXT( + VkCommandBuffer commandBuffer, + VkFrontFace frontFace); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopologyEXT( + VkCommandBuffer commandBuffer, + VkPrimitiveTopology primitiveTopology); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCountEXT( + VkCommandBuffer commandBuffer, + uint32_t viewportCount, + const VkViewport* pViewports); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCountEXT( + VkCommandBuffer commandBuffer, + uint32_t scissorCount, + const VkRect2D* pScissors); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2EXT( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes, + const VkDeviceSize* pStrides); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthTestEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthWriteEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOpEXT( + VkCommandBuffer commandBuffer, + VkCompareOp depthCompareOp); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthBoundsTestEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 stencilTestEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOpEXT( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + VkStencilOp failOp, + VkStencilOp passOp, + VkStencilOp depthFailOp, + VkCompareOp compareOp); +#endif + + +#define VK_EXT_shader_demote_to_helper_invocation 1 +#define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION 1 +#define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME "VK_EXT_shader_demote_to_helper_invocation" +typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderDemoteToHelperInvocation; +} VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; + + + +#define VK_EXT_texel_buffer_alignment 1 +#define VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION 1 +#define VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME "VK_EXT_texel_buffer_alignment" +typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 texelBufferAlignment; +} VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT; + +typedef struct VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize storageTexelBufferOffsetAlignmentBytes; + VkBool32 storageTexelBufferOffsetSingleTexelAlignment; + VkDeviceSize uniformTexelBufferOffsetAlignmentBytes; + VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; +} VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT; + + + +#define VK_EXT_robustness2 1 +#define VK_EXT_ROBUSTNESS_2_SPEC_VERSION 1 +#define VK_EXT_ROBUSTNESS_2_EXTENSION_NAME "VK_EXT_robustness2" +typedef struct VkPhysicalDeviceRobustness2FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 robustBufferAccess2; + VkBool32 robustImageAccess2; + VkBool32 nullDescriptor; +} VkPhysicalDeviceRobustness2FeaturesEXT; + +typedef struct VkPhysicalDeviceRobustness2PropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize robustStorageBufferAccessSizeAlignment; + VkDeviceSize robustUniformBufferAccessSizeAlignment; +} VkPhysicalDeviceRobustness2PropertiesEXT; + + + +#define VK_EXT_custom_border_color 1 +#define VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION 12 +#define VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME "VK_EXT_custom_border_color" +typedef struct VkSamplerCustomBorderColorCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkClearColorValue customBorderColor; + VkFormat format; +} VkSamplerCustomBorderColorCreateInfoEXT; + +typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxCustomBorderColorSamplers; +} VkPhysicalDeviceCustomBorderColorPropertiesEXT; + +typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 customBorderColors; + VkBool32 customBorderColorWithoutFormat; +} VkPhysicalDeviceCustomBorderColorFeaturesEXT; + + + +#define VK_EXT_ycbcr_2plane_444_formats 1 +#define VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION 1 +#define VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME "VK_EXT_ycbcr_2plane_444_formats" +typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 ycbcr2plane444Formats; +} VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; + + + +#define VK_EXT_image_robustness 1 +#define VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION 1 +#define VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_image_robustness" +typedef struct VkPhysicalDeviceImageRobustnessFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 robustImageAccess; +} VkPhysicalDeviceImageRobustnessFeaturesEXT; + + + +#define VK_EXT_4444_formats 1 +#define VK_EXT_4444_FORMATS_SPEC_VERSION 1 +#define VK_EXT_4444_FORMATS_EXTENSION_NAME "VK_EXT_4444_formats" +typedef struct VkPhysicalDevice4444FormatsFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 formatA4R4G4B4; + VkBool32 formatA4B4G4R4; +} VkPhysicalDevice4444FormatsFeaturesEXT; + + + +#define VK_EXT_vertex_input_dynamic_state 1 +#define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION 2 +#define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_vertex_input_dynamic_state" +typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 vertexInputDynamicState; +} VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT; + +typedef struct VkVertexInputBindingDescription2EXT { + VkStructureType sType; + void* pNext; + uint32_t binding; + uint32_t stride; + VkVertexInputRate inputRate; + uint32_t divisor; +} VkVertexInputBindingDescription2EXT; + +typedef struct VkVertexInputAttributeDescription2EXT { + VkStructureType sType; + void* pNext; + uint32_t location; + uint32_t binding; + VkFormat format; + uint32_t offset; +} VkVertexInputAttributeDescription2EXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetVertexInputEXT)(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetVertexInputEXT( + VkCommandBuffer commandBuffer, + uint32_t vertexBindingDescriptionCount, + const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, + uint32_t vertexAttributeDescriptionCount, + const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); +#endif + + +#define VK_EXT_extended_dynamic_state2 1 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION 1 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME "VK_EXT_extended_dynamic_state2" +typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 extendedDynamicState2; + VkBool32 extendedDynamicState2LogicOp; + VkBool32 extendedDynamicState2PatchControlPoints; +} VkPhysicalDeviceExtendedDynamicState2FeaturesEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer commandBuffer, uint32_t patchControlPoints); +typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBiasEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer commandBuffer, VkLogicOp logicOp); +typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetPatchControlPointsEXT( + VkCommandBuffer commandBuffer, + uint32_t patchControlPoints); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 rasterizerDiscardEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthBiasEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEXT( + VkCommandBuffer commandBuffer, + VkLogicOp logicOp); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 primitiveRestartEnable); +#endif + + +#define VK_EXT_color_write_enable 1 +#define VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION 1 +#define VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME "VK_EXT_color_write_enable" +typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 colorWriteEnable; +} VkPhysicalDeviceColorWriteEnableFeaturesEXT; + +typedef struct VkPipelineColorWriteCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t attachmentCount; + const VkBool32* pColorWriteEnables; +} VkPipelineColorWriteCreateInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetColorWriteEnableEXT)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteEnableEXT( + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkBool32* pColorWriteEnables); +#endif + + +#define VK_EXT_application_parameters 1 +#define VK_EXT_APPLICATION_PARAMETERS_SPEC_VERSION 1 +#define VK_EXT_APPLICATION_PARAMETERS_EXTENSION_NAME "VK_EXT_application_parameters" +typedef struct VkApplicationParametersEXT { + VkStructureType sType; + const void* pNext; + uint32_t vendorID; + uint32_t deviceID; + uint32_t key; + uint64_t value; +} VkApplicationParametersEXT; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/vulkan/vulkan_sc_core.hpp b/include/vulkan/vulkan_sc_core.hpp new file mode 100644 index 0000000..1f87756 --- /dev/null +++ b/include/vulkan/vulkan_sc_core.hpp @@ -0,0 +1,7774 @@ +#ifndef VULKAN_SC_CORE_H_PP +#define VULKAN_SC_CORE_H_PP 1 + +/* +** Copyright 2015-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define VK_VERSION_1_0 1 +#include "vk_platform.h" + +#define VK_DEFINE_HANDLE(object) typedef struct object##_T* (object); + + +#ifndef VK_USE_64_BIT_PTR_DEFINES + #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) + #define VK_USE_64_BIT_PTR_DEFINES 1 + #else + #define VK_USE_64_BIT_PTR_DEFINES 0 + #endif +#endif + + +#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE + #if (VK_USE_64_BIT_PTR_DEFINES==1) + #if (defined(__cplusplus) && (__cplusplus >= 201103L)) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201103L)) + #define VK_NULL_HANDLE nullptr + #else + #define VK_NULL_HANDLE ((void*)0) + #endif + #else + #define VK_NULL_HANDLE 0ULL + #endif +#endif +#ifndef VK_NULL_HANDLE + #define VK_NULL_HANDLE 0 +#endif + + +#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE + #if (VK_USE_64_BIT_PTR_DEFINES==1) + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *(object); + #else + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t (object); + #endif +#endif + +#define VK_MAKE_API_VERSION(variant, major, minor, patch) \ + ((((uint32_t)(variant)) << 29) | (((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch))) + +// Vulkan 1.0 version number +#define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0 + +// Version of this file +#define VK_HEADER_VERSION 9 + +// Vulkan SC variant number +#define VKSC_API_VARIANT 1 + +// Complete version of this file +#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, VK_HEADER_VERSION) + +#define VK_API_VERSION_VARIANT(version) ((uint32_t)(version) >> 29) +#define VK_API_VERSION_MAJOR(version) (((uint32_t)(version) >> 22) & 0x7FU) +#define VK_API_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3FFU) +#define VK_API_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU) +typedef uint32_t VkBool32; +typedef uint64_t VkDeviceAddress; +typedef uint64_t VkDeviceSize; +typedef uint32_t VkFlags; +typedef uint32_t VkSampleMask; +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) +VK_DEFINE_HANDLE(VkInstance) +VK_DEFINE_HANDLE(VkPhysicalDevice) +VK_DEFINE_HANDLE(VkDevice) +VK_DEFINE_HANDLE(VkQueue) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) +VK_DEFINE_HANDLE(VkCommandBuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) +static constexpr uint32_t VK_UUID_SIZE {static_cast(16U)}; +static constexpr uint32_t VK_ATTACHMENT_UNUSED {~static_cast(0U)}; +static constexpr uint32_t VK_FALSE {static_cast(0U)}; +static constexpr float VK_LOD_CLAMP_NONE {static_cast(1000.0F)}; +static constexpr uint32_t VK_QUEUE_FAMILY_IGNORED {~static_cast(0U)}; +static constexpr uint32_t VK_REMAINING_ARRAY_LAYERS {~static_cast(0U)}; +static constexpr uint32_t VK_REMAINING_MIP_LEVELS {~static_cast(0U)}; +static constexpr uint32_t VK_SUBPASS_EXTERNAL {~static_cast(0U)}; +static constexpr uint32_t VK_TRUE {static_cast(1U)}; +static constexpr uint64_t VK_WHOLE_SIZE {~static_cast(0U)}; +static constexpr uint32_t VK_MAX_MEMORY_TYPES {static_cast(32U)}; +static constexpr uint32_t VK_MAX_MEMORY_HEAPS {static_cast(16U)}; +static constexpr uint32_t VK_MAX_PHYSICAL_DEVICE_NAME_SIZE {static_cast(256U)}; +static constexpr uint32_t VK_MAX_EXTENSION_NAME_SIZE {static_cast(256U)}; +static constexpr uint32_t VK_MAX_DESCRIPTION_SIZE {static_cast(256U)}; + +typedef enum VkResult { + VK_SUCCESS = 0, + VK_NOT_READY = 1, + VK_TIMEOUT = 2, + VK_EVENT_SET = 3, + VK_EVENT_RESET = 4, + VK_INCOMPLETE = 5, + VK_ERROR_OUT_OF_HOST_MEMORY = -1, + VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, + VK_ERROR_INITIALIZATION_FAILED = -3, + VK_ERROR_DEVICE_LOST = -4, + VK_ERROR_MEMORY_MAP_FAILED = -5, + VK_ERROR_LAYER_NOT_PRESENT = -6, + VK_ERROR_EXTENSION_NOT_PRESENT = -7, + VK_ERROR_FEATURE_NOT_PRESENT = -8, + VK_ERROR_INCOMPATIBLE_DRIVER = -9, + VK_ERROR_TOO_MANY_OBJECTS = -10, + VK_ERROR_FORMAT_NOT_SUPPORTED = -11, + VK_ERROR_FRAGMENTED_POOL = -12, + VK_ERROR_UNKNOWN = -13, + VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000, + VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003, + VK_ERROR_FRAGMENTATION = -1000161000, + VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000, + VK_ERROR_VALIDATION_FAILED = -1000011001, + VK_ERROR_INVALID_PIPELINE_CACHE_DATA = -1000298000, + VK_ERROR_NO_PIPELINE_MATCH = -1000298001, + VK_ERROR_SURFACE_LOST_KHR = -1000000000, + VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, + VK_SUBOPTIMAL_KHR = 1000001003, + VK_ERROR_OUT_OF_DATE_KHR = -1000001004, + VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, + VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000, + VK_ERROR_NOT_PERMITTED_EXT = -1000174001, + VK_RESULT_MAX_ENUM = 0x7FFFFFFF +} VkResult; + +typedef enum VkStructureType { + VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, + VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, + VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, + VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, + VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, + VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, + VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, + VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, + VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, + VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, + VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, + VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001, + VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, + VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, + VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, + VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000, + VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, + VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, + VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, + VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, + VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, + VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, + VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 = 1000109000, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 = 1000109001, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 = 1000109002, + VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 = 1000109003, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004, + VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005, + VK_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000, + VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000, + VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000, + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001, + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002, + VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001, + VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO = 1000207002, + VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003, + VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004, + VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO = 1000244001, + VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002, + VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES = 1000298000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES = 1000298001, + VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO = 1000298002, + VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO = 1000298003, + VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_CONSUMPTION = 1000298004, + VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE = 1000298005, + VK_STRUCTURE_TYPE_FAULT_DATA = 1000298007, + VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO = 1000298008, + VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO = 1000298010, + VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, + VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, + VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009, + VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012, + VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, + VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, + VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = 1000066000, + VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, + VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, + VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, + VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000, + VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, + VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, + VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, + VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, + VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001, + VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, + VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, + VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, + VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001, + VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002, + VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003, + VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004, + VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005, + VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006, + VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR = 1000116007, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, + VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, + VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001, + VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004, + VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000, + VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001, + VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002, + VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003, + VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004, + VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000, + VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, + VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, + VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, + VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005, + VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT = 1000158006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000, + VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, + VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000, + VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR = 1000215000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = 1000225000, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = 1000225001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = 1000225002, + VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000226000, + VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR = 1000226001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR = 1000226002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR = 1000226003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000, + VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000, + VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = 1000276000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = 1000281001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001, + VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002, + VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR = 1000308000, + VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR = 1000314000, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR = 1000314001, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR = 1000314002, + VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR = 1000314003, + VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR = 1000314004, + VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR = 1000314005, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR = 1000314006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR = 1000314007, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008, + VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV = 1000314009, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT = 1000330000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT = 1000335000, + VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR = 1000337000, + VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR = 1000337001, + VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR = 1000337002, + VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR = 1000337003, + VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR = 1000337004, + VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR = 1000337005, + VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR = 1000337006, + VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR = 1000337007, + VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR = 1000337008, + VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR = 1000337009, + VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR = 1000337010, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000, + VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001, + VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT = 1000377000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT = 1000381000, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001, + VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT = 1000435000, + VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkStructureType; + +typedef enum VkImageLayout { + VK_IMAGE_LAYOUT_UNDEFINED = 0, + VK_IMAGE_LAYOUT_GENERAL = 1, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, + VK_IMAGE_LAYOUT_PREINITIALIZED = 8, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001, + VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002, + VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003, + VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, + VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, + VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003, + VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR = 1000314000, + VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR = 1000314001, + VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF +} VkImageLayout; + +typedef enum VkObjectType { + VK_OBJECT_TYPE_UNKNOWN = 0, + VK_OBJECT_TYPE_INSTANCE = 1, + VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2, + VK_OBJECT_TYPE_DEVICE = 3, + VK_OBJECT_TYPE_QUEUE = 4, + VK_OBJECT_TYPE_SEMAPHORE = 5, + VK_OBJECT_TYPE_COMMAND_BUFFER = 6, + VK_OBJECT_TYPE_FENCE = 7, + VK_OBJECT_TYPE_DEVICE_MEMORY = 8, + VK_OBJECT_TYPE_BUFFER = 9, + VK_OBJECT_TYPE_IMAGE = 10, + VK_OBJECT_TYPE_EVENT = 11, + VK_OBJECT_TYPE_QUERY_POOL = 12, + VK_OBJECT_TYPE_BUFFER_VIEW = 13, + VK_OBJECT_TYPE_IMAGE_VIEW = 14, + VK_OBJECT_TYPE_PIPELINE_CACHE = 16, + VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17, + VK_OBJECT_TYPE_RENDER_PASS = 18, + VK_OBJECT_TYPE_PIPELINE = 19, + VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20, + VK_OBJECT_TYPE_SAMPLER = 21, + VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22, + VK_OBJECT_TYPE_DESCRIPTOR_SET = 23, + VK_OBJECT_TYPE_FRAMEBUFFER = 24, + VK_OBJECT_TYPE_COMMAND_POOL = 25, + VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000, + VK_OBJECT_TYPE_SURFACE_KHR = 1000000000, + VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000, + VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000, + VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001, + VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000, + VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkObjectType; + +typedef enum VkPipelineCacheHeaderVersion { + VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, + VK_PIPELINE_CACHE_HEADER_VERSION_SAFETY_CRITICAL_ONE = 1000298001, + VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCacheHeaderVersion; + +typedef enum VkVendorId { + VK_VENDOR_ID_VIV = 0x10001, + VK_VENDOR_ID_VSI = 0x10002, + VK_VENDOR_ID_KAZAN = 0x10003, + VK_VENDOR_ID_CODEPLAY = 0x10004, + VK_VENDOR_ID_MESA = 0x10005, + VK_VENDOR_ID_POCL = 0x10006, + VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF +} VkVendorId; + +typedef enum VkSystemAllocationScope { + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, + VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, + VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, + VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, + VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF +} VkSystemAllocationScope; + +typedef enum VkInternalAllocationType { + VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, + VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkInternalAllocationType; + +typedef enum VkFormat { + VK_FORMAT_UNDEFINED = 0, + VK_FORMAT_R4G4_UNORM_PACK8 = 1, + VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, + VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, + VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, + VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, + VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, + VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, + VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, + VK_FORMAT_R8_UNORM = 9, + VK_FORMAT_R8_SNORM = 10, + VK_FORMAT_R8_USCALED = 11, + VK_FORMAT_R8_SSCALED = 12, + VK_FORMAT_R8_UINT = 13, + VK_FORMAT_R8_SINT = 14, + VK_FORMAT_R8_SRGB = 15, + VK_FORMAT_R8G8_UNORM = 16, + VK_FORMAT_R8G8_SNORM = 17, + VK_FORMAT_R8G8_USCALED = 18, + VK_FORMAT_R8G8_SSCALED = 19, + VK_FORMAT_R8G8_UINT = 20, + VK_FORMAT_R8G8_SINT = 21, + VK_FORMAT_R8G8_SRGB = 22, + VK_FORMAT_R8G8B8_UNORM = 23, + VK_FORMAT_R8G8B8_SNORM = 24, + VK_FORMAT_R8G8B8_USCALED = 25, + VK_FORMAT_R8G8B8_SSCALED = 26, + VK_FORMAT_R8G8B8_UINT = 27, + VK_FORMAT_R8G8B8_SINT = 28, + VK_FORMAT_R8G8B8_SRGB = 29, + VK_FORMAT_B8G8R8_UNORM = 30, + VK_FORMAT_B8G8R8_SNORM = 31, + VK_FORMAT_B8G8R8_USCALED = 32, + VK_FORMAT_B8G8R8_SSCALED = 33, + VK_FORMAT_B8G8R8_UINT = 34, + VK_FORMAT_B8G8R8_SINT = 35, + VK_FORMAT_B8G8R8_SRGB = 36, + VK_FORMAT_R8G8B8A8_UNORM = 37, + VK_FORMAT_R8G8B8A8_SNORM = 38, + VK_FORMAT_R8G8B8A8_USCALED = 39, + VK_FORMAT_R8G8B8A8_SSCALED = 40, + VK_FORMAT_R8G8B8A8_UINT = 41, + VK_FORMAT_R8G8B8A8_SINT = 42, + VK_FORMAT_R8G8B8A8_SRGB = 43, + VK_FORMAT_B8G8R8A8_UNORM = 44, + VK_FORMAT_B8G8R8A8_SNORM = 45, + VK_FORMAT_B8G8R8A8_USCALED = 46, + VK_FORMAT_B8G8R8A8_SSCALED = 47, + VK_FORMAT_B8G8R8A8_UINT = 48, + VK_FORMAT_B8G8R8A8_SINT = 49, + VK_FORMAT_B8G8R8A8_SRGB = 50, + VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, + VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, + VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, + VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, + VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, + VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, + VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, + VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, + VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, + VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, + VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, + VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, + VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, + VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, + VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, + VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, + VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, + VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, + VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, + VK_FORMAT_R16_UNORM = 70, + VK_FORMAT_R16_SNORM = 71, + VK_FORMAT_R16_USCALED = 72, + VK_FORMAT_R16_SSCALED = 73, + VK_FORMAT_R16_UINT = 74, + VK_FORMAT_R16_SINT = 75, + VK_FORMAT_R16_SFLOAT = 76, + VK_FORMAT_R16G16_UNORM = 77, + VK_FORMAT_R16G16_SNORM = 78, + VK_FORMAT_R16G16_USCALED = 79, + VK_FORMAT_R16G16_SSCALED = 80, + VK_FORMAT_R16G16_UINT = 81, + VK_FORMAT_R16G16_SINT = 82, + VK_FORMAT_R16G16_SFLOAT = 83, + VK_FORMAT_R16G16B16_UNORM = 84, + VK_FORMAT_R16G16B16_SNORM = 85, + VK_FORMAT_R16G16B16_USCALED = 86, + VK_FORMAT_R16G16B16_SSCALED = 87, + VK_FORMAT_R16G16B16_UINT = 88, + VK_FORMAT_R16G16B16_SINT = 89, + VK_FORMAT_R16G16B16_SFLOAT = 90, + VK_FORMAT_R16G16B16A16_UNORM = 91, + VK_FORMAT_R16G16B16A16_SNORM = 92, + VK_FORMAT_R16G16B16A16_USCALED = 93, + VK_FORMAT_R16G16B16A16_SSCALED = 94, + VK_FORMAT_R16G16B16A16_UINT = 95, + VK_FORMAT_R16G16B16A16_SINT = 96, + VK_FORMAT_R16G16B16A16_SFLOAT = 97, + VK_FORMAT_R32_UINT = 98, + VK_FORMAT_R32_SINT = 99, + VK_FORMAT_R32_SFLOAT = 100, + VK_FORMAT_R32G32_UINT = 101, + VK_FORMAT_R32G32_SINT = 102, + VK_FORMAT_R32G32_SFLOAT = 103, + VK_FORMAT_R32G32B32_UINT = 104, + VK_FORMAT_R32G32B32_SINT = 105, + VK_FORMAT_R32G32B32_SFLOAT = 106, + VK_FORMAT_R32G32B32A32_UINT = 107, + VK_FORMAT_R32G32B32A32_SINT = 108, + VK_FORMAT_R32G32B32A32_SFLOAT = 109, + VK_FORMAT_R64_UINT = 110, + VK_FORMAT_R64_SINT = 111, + VK_FORMAT_R64_SFLOAT = 112, + VK_FORMAT_R64G64_UINT = 113, + VK_FORMAT_R64G64_SINT = 114, + VK_FORMAT_R64G64_SFLOAT = 115, + VK_FORMAT_R64G64B64_UINT = 116, + VK_FORMAT_R64G64B64_SINT = 117, + VK_FORMAT_R64G64B64_SFLOAT = 118, + VK_FORMAT_R64G64B64A64_UINT = 119, + VK_FORMAT_R64G64B64A64_SINT = 120, + VK_FORMAT_R64G64B64A64_SFLOAT = 121, + VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, + VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, + VK_FORMAT_D16_UNORM = 124, + VK_FORMAT_X8_D24_UNORM_PACK32 = 125, + VK_FORMAT_D32_SFLOAT = 126, + VK_FORMAT_S8_UINT = 127, + VK_FORMAT_D16_UNORM_S8_UINT = 128, + VK_FORMAT_D24_UNORM_S8_UINT = 129, + VK_FORMAT_D32_SFLOAT_S8_UINT = 130, + VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, + VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, + VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, + VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, + VK_FORMAT_BC2_UNORM_BLOCK = 135, + VK_FORMAT_BC2_SRGB_BLOCK = 136, + VK_FORMAT_BC3_UNORM_BLOCK = 137, + VK_FORMAT_BC3_SRGB_BLOCK = 138, + VK_FORMAT_BC4_UNORM_BLOCK = 139, + VK_FORMAT_BC4_SNORM_BLOCK = 140, + VK_FORMAT_BC5_UNORM_BLOCK = 141, + VK_FORMAT_BC5_SNORM_BLOCK = 142, + VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, + VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, + VK_FORMAT_BC7_UNORM_BLOCK = 145, + VK_FORMAT_BC7_SRGB_BLOCK = 146, + VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, + VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, + VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, + VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, + VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, + VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, + VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, + VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, + VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, + VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, + VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, + VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, + VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, + VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, + VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, + VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, + VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, + VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, + VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, + VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, + VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, + VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, + VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, + VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, + VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, + VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, + VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, + VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, + VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, + VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, + VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, + VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, + VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, + VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, + VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, + VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, + VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, + VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, + VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000, + VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001, + VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002, + VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003, + VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004, + VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005, + VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006, + VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007, + VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008, + VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009, + VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010, + VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016, + VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017, + VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018, + VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019, + VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020, + VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026, + VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027, + VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028, + VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029, + VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030, + VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031, + VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032, + VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033, + VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = 1000066000, + VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = 1000066001, + VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = 1000066002, + VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = 1000066003, + VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = 1000066004, + VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = 1000066005, + VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = 1000066006, + VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = 1000066007, + VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = 1000066008, + VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = 1000066009, + VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = 1000066010, + VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = 1000066011, + VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = 1000066012, + VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = 1000066013, + VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT = 1000330000, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT = 1000330001, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT = 1000330002, + VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT = 1000330003, + VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT = 1000340000, + VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT = 1000340001, + VK_FORMAT_MAX_ENUM = 0x7FFFFFFF +} VkFormat; + +typedef enum VkImageTiling { + VK_IMAGE_TILING_OPTIMAL = 0, + VK_IMAGE_TILING_LINEAR = 1, + VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000, + VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF +} VkImageTiling; + +typedef enum VkImageType { + VK_IMAGE_TYPE_1D = 0, + VK_IMAGE_TYPE_2D = 1, + VK_IMAGE_TYPE_3D = 2, + VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageType; + +typedef enum VkPhysicalDeviceType { + VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, + VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, + VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, + VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, + VK_PHYSICAL_DEVICE_TYPE_CPU = 4, + VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkPhysicalDeviceType; + +typedef enum VkQueryType { + VK_QUERY_TYPE_OCCLUSION = 0, + VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, + VK_QUERY_TYPE_TIMESTAMP = 2, + VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000, + VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkQueryType; + +typedef enum VkSharingMode { + VK_SHARING_MODE_EXCLUSIVE = 0, + VK_SHARING_MODE_CONCURRENT = 1, + VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSharingMode; + +typedef enum VkComponentSwizzle { + VK_COMPONENT_SWIZZLE_IDENTITY = 0, + VK_COMPONENT_SWIZZLE_ZERO = 1, + VK_COMPONENT_SWIZZLE_ONE = 2, + VK_COMPONENT_SWIZZLE_R = 3, + VK_COMPONENT_SWIZZLE_G = 4, + VK_COMPONENT_SWIZZLE_B = 5, + VK_COMPONENT_SWIZZLE_A = 6, + VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF +} VkComponentSwizzle; + +typedef enum VkImageViewType { + VK_IMAGE_VIEW_TYPE_1D = 0, + VK_IMAGE_VIEW_TYPE_2D = 1, + VK_IMAGE_VIEW_TYPE_3D = 2, + VK_IMAGE_VIEW_TYPE_CUBE = 3, + VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, + VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, + VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, + VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageViewType; + +typedef enum VkBlendFactor { + VK_BLEND_FACTOR_ZERO = 0, + VK_BLEND_FACTOR_ONE = 1, + VK_BLEND_FACTOR_SRC_COLOR = 2, + VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, + VK_BLEND_FACTOR_DST_COLOR = 4, + VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, + VK_BLEND_FACTOR_SRC_ALPHA = 6, + VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, + VK_BLEND_FACTOR_DST_ALPHA = 8, + VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, + VK_BLEND_FACTOR_CONSTANT_COLOR = 10, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, + VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, + VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, + VK_BLEND_FACTOR_SRC1_COLOR = 15, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, + VK_BLEND_FACTOR_SRC1_ALPHA = 17, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, + VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF +} VkBlendFactor; + +typedef enum VkBlendOp { + VK_BLEND_OP_ADD = 0, + VK_BLEND_OP_SUBTRACT = 1, + VK_BLEND_OP_REVERSE_SUBTRACT = 2, + VK_BLEND_OP_MIN = 3, + VK_BLEND_OP_MAX = 4, + VK_BLEND_OP_ZERO_EXT = 1000148000, + VK_BLEND_OP_SRC_EXT = 1000148001, + VK_BLEND_OP_DST_EXT = 1000148002, + VK_BLEND_OP_SRC_OVER_EXT = 1000148003, + VK_BLEND_OP_DST_OVER_EXT = 1000148004, + VK_BLEND_OP_SRC_IN_EXT = 1000148005, + VK_BLEND_OP_DST_IN_EXT = 1000148006, + VK_BLEND_OP_SRC_OUT_EXT = 1000148007, + VK_BLEND_OP_DST_OUT_EXT = 1000148008, + VK_BLEND_OP_SRC_ATOP_EXT = 1000148009, + VK_BLEND_OP_DST_ATOP_EXT = 1000148010, + VK_BLEND_OP_XOR_EXT = 1000148011, + VK_BLEND_OP_MULTIPLY_EXT = 1000148012, + VK_BLEND_OP_SCREEN_EXT = 1000148013, + VK_BLEND_OP_OVERLAY_EXT = 1000148014, + VK_BLEND_OP_DARKEN_EXT = 1000148015, + VK_BLEND_OP_LIGHTEN_EXT = 1000148016, + VK_BLEND_OP_COLORDODGE_EXT = 1000148017, + VK_BLEND_OP_COLORBURN_EXT = 1000148018, + VK_BLEND_OP_HARDLIGHT_EXT = 1000148019, + VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020, + VK_BLEND_OP_DIFFERENCE_EXT = 1000148021, + VK_BLEND_OP_EXCLUSION_EXT = 1000148022, + VK_BLEND_OP_INVERT_EXT = 1000148023, + VK_BLEND_OP_INVERT_RGB_EXT = 1000148024, + VK_BLEND_OP_LINEARDODGE_EXT = 1000148025, + VK_BLEND_OP_LINEARBURN_EXT = 1000148026, + VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027, + VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028, + VK_BLEND_OP_PINLIGHT_EXT = 1000148029, + VK_BLEND_OP_HARDMIX_EXT = 1000148030, + VK_BLEND_OP_HSL_HUE_EXT = 1000148031, + VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032, + VK_BLEND_OP_HSL_COLOR_EXT = 1000148033, + VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034, + VK_BLEND_OP_PLUS_EXT = 1000148035, + VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036, + VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037, + VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038, + VK_BLEND_OP_MINUS_EXT = 1000148039, + VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040, + VK_BLEND_OP_CONTRAST_EXT = 1000148041, + VK_BLEND_OP_INVERT_OVG_EXT = 1000148042, + VK_BLEND_OP_RED_EXT = 1000148043, + VK_BLEND_OP_GREEN_EXT = 1000148044, + VK_BLEND_OP_BLUE_EXT = 1000148045, + VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF +} VkBlendOp; + +typedef enum VkCompareOp { + VK_COMPARE_OP_NEVER = 0, + VK_COMPARE_OP_LESS = 1, + VK_COMPARE_OP_EQUAL = 2, + VK_COMPARE_OP_LESS_OR_EQUAL = 3, + VK_COMPARE_OP_GREATER = 4, + VK_COMPARE_OP_NOT_EQUAL = 5, + VK_COMPARE_OP_GREATER_OR_EQUAL = 6, + VK_COMPARE_OP_ALWAYS = 7, + VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF +} VkCompareOp; + +typedef enum VkDynamicState { + VK_DYNAMIC_STATE_VIEWPORT = 0, + VK_DYNAMIC_STATE_SCISSOR = 1, + VK_DYNAMIC_STATE_LINE_WIDTH = 2, + VK_DYNAMIC_STATE_DEPTH_BIAS = 3, + VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, + VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, + VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, + VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, + VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, + VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, + VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000, + VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000, + VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000, + VK_DYNAMIC_STATE_CULL_MODE_EXT = 1000267000, + VK_DYNAMIC_STATE_FRONT_FACE_EXT = 1000267001, + VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = 1000267002, + VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT = 1000267003, + VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT = 1000267004, + VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT = 1000267005, + VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT = 1000267006, + VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT = 1000267007, + VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT = 1000267008, + VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT = 1000267009, + VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT = 1000267010, + VK_DYNAMIC_STATE_STENCIL_OP_EXT = 1000267011, + VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000, + VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000, + VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT = 1000377001, + VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT = 1000377002, + VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003, + VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT = 1000377004, + VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000, + VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF +} VkDynamicState; + +typedef enum VkFrontFace { + VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, + VK_FRONT_FACE_CLOCKWISE = 1, + VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF +} VkFrontFace; + +typedef enum VkVertexInputRate { + VK_VERTEX_INPUT_RATE_VERTEX = 0, + VK_VERTEX_INPUT_RATE_INSTANCE = 1, + VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF +} VkVertexInputRate; + +typedef enum VkPrimitiveTopology { + VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, + VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, + VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF +} VkPrimitiveTopology; + +typedef enum VkPolygonMode { + VK_POLYGON_MODE_FILL = 0, + VK_POLYGON_MODE_LINE = 1, + VK_POLYGON_MODE_POINT = 2, + VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF +} VkPolygonMode; + +typedef enum VkStencilOp { + VK_STENCIL_OP_KEEP = 0, + VK_STENCIL_OP_ZERO = 1, + VK_STENCIL_OP_REPLACE = 2, + VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, + VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, + VK_STENCIL_OP_INVERT = 5, + VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, + VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, + VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF +} VkStencilOp; + +typedef enum VkLogicOp { + VK_LOGIC_OP_CLEAR = 0, + VK_LOGIC_OP_AND = 1, + VK_LOGIC_OP_AND_REVERSE = 2, + VK_LOGIC_OP_COPY = 3, + VK_LOGIC_OP_AND_INVERTED = 4, + VK_LOGIC_OP_NO_OP = 5, + VK_LOGIC_OP_XOR = 6, + VK_LOGIC_OP_OR = 7, + VK_LOGIC_OP_NOR = 8, + VK_LOGIC_OP_EQUIVALENT = 9, + VK_LOGIC_OP_INVERT = 10, + VK_LOGIC_OP_OR_REVERSE = 11, + VK_LOGIC_OP_COPY_INVERTED = 12, + VK_LOGIC_OP_OR_INVERTED = 13, + VK_LOGIC_OP_NAND = 14, + VK_LOGIC_OP_SET = 15, + VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF +} VkLogicOp; + +typedef enum VkBorderColor { + VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, + VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, + VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, + VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, + VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, + VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, + VK_BORDER_COLOR_FLOAT_CUSTOM_EXT = 1000287003, + VK_BORDER_COLOR_INT_CUSTOM_EXT = 1000287004, + VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF +} VkBorderColor; + +typedef enum VkFilter { + VK_FILTER_NEAREST = 0, + VK_FILTER_LINEAR = 1, + VK_FILTER_CUBIC_IMG = 1000015000, + VK_FILTER_CUBIC_EXT = VK_FILTER_CUBIC_IMG, + VK_FILTER_MAX_ENUM = 0x7FFFFFFF +} VkFilter; + +typedef enum VkSamplerAddressMode { + VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, + VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, + VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, + VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerAddressMode; + +typedef enum VkSamplerMipmapMode { + VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, + VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, + VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerMipmapMode; + +typedef enum VkDescriptorType { + VK_DESCRIPTOR_TYPE_SAMPLER = 0, + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, + VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, + VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, + VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, + VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, + VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, + VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorType; + +typedef enum VkAttachmentLoadOp { + VK_ATTACHMENT_LOAD_OP_LOAD = 0, + VK_ATTACHMENT_LOAD_OP_CLEAR = 1, + VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, + VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentLoadOp; + +typedef enum VkAttachmentStoreOp { + VK_ATTACHMENT_STORE_OP_STORE = 0, + VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, + VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentStoreOp; + +typedef enum VkPipelineBindPoint { + VK_PIPELINE_BIND_POINT_GRAPHICS = 0, + VK_PIPELINE_BIND_POINT_COMPUTE = 1, + VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF +} VkPipelineBindPoint; + +typedef enum VkCommandBufferLevel { + VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, + VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, + VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferLevel; + +typedef enum VkIndexType { + VK_INDEX_TYPE_UINT16 = 0, + VK_INDEX_TYPE_UINT32 = 1, + VK_INDEX_TYPE_UINT8_EXT = 1000265000, + VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkIndexType; + +typedef enum VkSubpassContents { + VK_SUBPASS_CONTENTS_INLINE = 0, + VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, + VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF +} VkSubpassContents; + +// Flag bits for VkAccessFlagBits +typedef VkFlags VkAccessFlagBits; +static constexpr VkAccessFlagBits VK_ACCESS_INDIRECT_COMMAND_READ_BIT {0x00000001U}; +static constexpr VkAccessFlagBits VK_ACCESS_INDEX_READ_BIT {0x00000002U}; +static constexpr VkAccessFlagBits VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT {0x00000004U}; +static constexpr VkAccessFlagBits VK_ACCESS_UNIFORM_READ_BIT {0x00000008U}; +static constexpr VkAccessFlagBits VK_ACCESS_INPUT_ATTACHMENT_READ_BIT {0x00000010U}; +static constexpr VkAccessFlagBits VK_ACCESS_SHADER_READ_BIT {0x00000020U}; +static constexpr VkAccessFlagBits VK_ACCESS_SHADER_WRITE_BIT {0x00000040U}; +static constexpr VkAccessFlagBits VK_ACCESS_COLOR_ATTACHMENT_READ_BIT {0x00000080U}; +static constexpr VkAccessFlagBits VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT {0x00000100U}; +static constexpr VkAccessFlagBits VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT {0x00000200U}; +static constexpr VkAccessFlagBits VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT {0x00000400U}; +static constexpr VkAccessFlagBits VK_ACCESS_TRANSFER_READ_BIT {0x00000800U}; +static constexpr VkAccessFlagBits VK_ACCESS_TRANSFER_WRITE_BIT {0x00001000U}; +static constexpr VkAccessFlagBits VK_ACCESS_HOST_READ_BIT {0x00002000U}; +static constexpr VkAccessFlagBits VK_ACCESS_HOST_WRITE_BIT {0x00004000U}; +static constexpr VkAccessFlagBits VK_ACCESS_MEMORY_READ_BIT {0x00008000U}; +static constexpr VkAccessFlagBits VK_ACCESS_MEMORY_WRITE_BIT {0x00010000U}; +static constexpr VkAccessFlagBits VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT {0x00080000U}; +static constexpr VkAccessFlagBits VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR {0x00800000U}; +static constexpr VkAccessFlagBits VK_ACCESS_NONE_KHR {0U}; + +typedef VkFlags VkAccessFlags; + +// Flag bits for VkImageAspectFlagBits +typedef VkFlags VkImageAspectFlagBits; +static constexpr VkImageAspectFlagBits VK_IMAGE_ASPECT_COLOR_BIT {0x00000001U}; +static constexpr VkImageAspectFlagBits VK_IMAGE_ASPECT_DEPTH_BIT {0x00000002U}; +static constexpr VkImageAspectFlagBits VK_IMAGE_ASPECT_STENCIL_BIT {0x00000004U}; +static constexpr VkImageAspectFlagBits VK_IMAGE_ASPECT_METADATA_BIT {0x00000008U}; +static constexpr VkImageAspectFlagBits VK_IMAGE_ASPECT_PLANE_0_BIT {0x00000010U}; +static constexpr VkImageAspectFlagBits VK_IMAGE_ASPECT_PLANE_1_BIT {0x00000020U}; +static constexpr VkImageAspectFlagBits VK_IMAGE_ASPECT_PLANE_2_BIT {0x00000040U}; +static constexpr VkImageAspectFlagBits VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT {0x00000080U}; +static constexpr VkImageAspectFlagBits VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT {0x00000100U}; +static constexpr VkImageAspectFlagBits VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT {0x00000200U}; +static constexpr VkImageAspectFlagBits VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT {0x00000400U}; + +typedef VkFlags VkImageAspectFlags; + +// Flag bits for VkFormatFeatureFlagBits +typedef VkFlags VkFormatFeatureFlagBits; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT {0x00000001U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT {0x00000002U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT {0x00000004U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT {0x00000008U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT {0x00000010U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT {0x00000020U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT {0x00000040U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT {0x00000080U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT {0x00000100U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT {0x00000200U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_BLIT_SRC_BIT {0x00000400U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_BLIT_DST_BIT {0x00000800U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT {0x00001000U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_TRANSFER_SRC_BIT {0x00004000U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_TRANSFER_DST_BIT {0x00008000U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT {0x00020000U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT {0x00040000U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT {0x00080000U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT {0x00100000U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT {0x00200000U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_DISJOINT_BIT {0x00400000U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT {0x00800000U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT {0x00010000U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG {0x00002000U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR {0x40000000U}; +static constexpr VkFormatFeatureFlagBits VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT {VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG}; + +typedef VkFlags VkFormatFeatureFlags; + +// Flag bits for VkImageCreateFlagBits +typedef VkFlags VkImageCreateFlagBits; +static constexpr VkImageCreateFlagBits VK_IMAGE_CREATE_SPARSE_BINDING_BIT {0x00000001U}; +static constexpr VkImageCreateFlagBits VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT {0x00000002U}; +static constexpr VkImageCreateFlagBits VK_IMAGE_CREATE_SPARSE_ALIASED_BIT {0x00000004U}; +static constexpr VkImageCreateFlagBits VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT {0x00000008U}; +static constexpr VkImageCreateFlagBits VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT {0x00000010U}; +static constexpr VkImageCreateFlagBits VK_IMAGE_CREATE_ALIAS_BIT {0x00000400U}; +static constexpr VkImageCreateFlagBits VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT {0x00000040U}; +static constexpr VkImageCreateFlagBits VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT {0x00000020U}; +static constexpr VkImageCreateFlagBits VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT {0x00000080U}; +static constexpr VkImageCreateFlagBits VK_IMAGE_CREATE_EXTENDED_USAGE_BIT {0x00000100U}; +static constexpr VkImageCreateFlagBits VK_IMAGE_CREATE_PROTECTED_BIT {0x00000800U}; +static constexpr VkImageCreateFlagBits VK_IMAGE_CREATE_DISJOINT_BIT {0x00000200U}; +static constexpr VkImageCreateFlagBits VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT {0x00001000U}; + +typedef VkFlags VkImageCreateFlags; + +// Flag bits for VkSampleCountFlagBits +typedef VkFlags VkSampleCountFlagBits; +static constexpr VkSampleCountFlagBits VK_SAMPLE_COUNT_1_BIT {0x00000001U}; +static constexpr VkSampleCountFlagBits VK_SAMPLE_COUNT_2_BIT {0x00000002U}; +static constexpr VkSampleCountFlagBits VK_SAMPLE_COUNT_4_BIT {0x00000004U}; +static constexpr VkSampleCountFlagBits VK_SAMPLE_COUNT_8_BIT {0x00000008U}; +static constexpr VkSampleCountFlagBits VK_SAMPLE_COUNT_16_BIT {0x00000010U}; +static constexpr VkSampleCountFlagBits VK_SAMPLE_COUNT_32_BIT {0x00000020U}; +static constexpr VkSampleCountFlagBits VK_SAMPLE_COUNT_64_BIT {0x00000040U}; + +typedef VkFlags VkSampleCountFlags; + +// Flag bits for VkImageUsageFlagBits +typedef VkFlags VkImageUsageFlagBits; +static constexpr VkImageUsageFlagBits VK_IMAGE_USAGE_TRANSFER_SRC_BIT {0x00000001U}; +static constexpr VkImageUsageFlagBits VK_IMAGE_USAGE_TRANSFER_DST_BIT {0x00000002U}; +static constexpr VkImageUsageFlagBits VK_IMAGE_USAGE_SAMPLED_BIT {0x00000004U}; +static constexpr VkImageUsageFlagBits VK_IMAGE_USAGE_STORAGE_BIT {0x00000008U}; +static constexpr VkImageUsageFlagBits VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT {0x00000010U}; +static constexpr VkImageUsageFlagBits VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT {0x00000020U}; +static constexpr VkImageUsageFlagBits VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT {0x00000040U}; +static constexpr VkImageUsageFlagBits VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT {0x00000080U}; +static constexpr VkImageUsageFlagBits VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR {0x00000100U}; + +typedef VkFlags VkImageUsageFlags; +typedef VkFlags VkInstanceCreateFlags; + +// Flag bits for VkMemoryHeapFlagBits +typedef VkFlags VkMemoryHeapFlagBits; +static constexpr VkMemoryHeapFlagBits VK_MEMORY_HEAP_DEVICE_LOCAL_BIT {0x00000001U}; +static constexpr VkMemoryHeapFlagBits VK_MEMORY_HEAP_MULTI_INSTANCE_BIT {0x00000002U}; +static constexpr VkMemoryHeapFlagBits VK_MEMORY_HEAP_SEU_SAFE_BIT {0x00000004U}; + +typedef VkFlags VkMemoryHeapFlags; + +// Flag bits for VkMemoryPropertyFlagBits +typedef VkFlags VkMemoryPropertyFlagBits; +static constexpr VkMemoryPropertyFlagBits VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT {0x00000001U}; +static constexpr VkMemoryPropertyFlagBits VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT {0x00000002U}; +static constexpr VkMemoryPropertyFlagBits VK_MEMORY_PROPERTY_HOST_COHERENT_BIT {0x00000004U}; +static constexpr VkMemoryPropertyFlagBits VK_MEMORY_PROPERTY_HOST_CACHED_BIT {0x00000008U}; +static constexpr VkMemoryPropertyFlagBits VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT {0x00000010U}; +static constexpr VkMemoryPropertyFlagBits VK_MEMORY_PROPERTY_PROTECTED_BIT {0x00000020U}; + +typedef VkFlags VkMemoryPropertyFlags; + +// Flag bits for VkQueueFlagBits +typedef VkFlags VkQueueFlagBits; +static constexpr VkQueueFlagBits VK_QUEUE_GRAPHICS_BIT {0x00000001U}; +static constexpr VkQueueFlagBits VK_QUEUE_COMPUTE_BIT {0x00000002U}; +static constexpr VkQueueFlagBits VK_QUEUE_TRANSFER_BIT {0x00000004U}; +static constexpr VkQueueFlagBits VK_QUEUE_PROTECTED_BIT {0x00000010U}; + +typedef VkFlags VkQueueFlags; +typedef VkFlags VkDeviceCreateFlags; + +// Flag bits for VkDeviceQueueCreateFlagBits +typedef VkFlags VkDeviceQueueCreateFlagBits; +static constexpr VkDeviceQueueCreateFlagBits VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT {0x00000001U}; + +typedef VkFlags VkDeviceQueueCreateFlags; + +// Flag bits for VkPipelineStageFlagBits +typedef VkFlags VkPipelineStageFlagBits; +static constexpr VkPipelineStageFlagBits VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT {0x00000001U}; +static constexpr VkPipelineStageFlagBits VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT {0x00000002U}; +static constexpr VkPipelineStageFlagBits VK_PIPELINE_STAGE_VERTEX_INPUT_BIT {0x00000004U}; +static constexpr VkPipelineStageFlagBits VK_PIPELINE_STAGE_VERTEX_SHADER_BIT {0x00000008U}; +static constexpr VkPipelineStageFlagBits VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT {0x00000010U}; +static constexpr VkPipelineStageFlagBits VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT {0x00000020U}; +static constexpr VkPipelineStageFlagBits VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT {0x00000040U}; +static constexpr VkPipelineStageFlagBits VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT {0x00000080U}; +static constexpr VkPipelineStageFlagBits VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT {0x00000100U}; +static constexpr VkPipelineStageFlagBits VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT {0x00000200U}; +static constexpr VkPipelineStageFlagBits VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT {0x00000400U}; +static constexpr VkPipelineStageFlagBits VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT {0x00000800U}; +static constexpr VkPipelineStageFlagBits VK_PIPELINE_STAGE_TRANSFER_BIT {0x00001000U}; +static constexpr VkPipelineStageFlagBits VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT {0x00002000U}; +static constexpr VkPipelineStageFlagBits VK_PIPELINE_STAGE_HOST_BIT {0x00004000U}; +static constexpr VkPipelineStageFlagBits VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT {0x00008000U}; +static constexpr VkPipelineStageFlagBits VK_PIPELINE_STAGE_ALL_COMMANDS_BIT {0x00010000U}; +static constexpr VkPipelineStageFlagBits VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR {0x00400000U}; +static constexpr VkPipelineStageFlagBits VK_PIPELINE_STAGE_NONE_KHR {0U}; + +typedef VkFlags VkPipelineStageFlags; +typedef VkFlags VkMemoryMapFlags; + +// Flag bits for VkFenceCreateFlagBits +typedef VkFlags VkFenceCreateFlagBits; +static constexpr VkFenceCreateFlagBits VK_FENCE_CREATE_SIGNALED_BIT {0x00000001U}; + +typedef VkFlags VkFenceCreateFlags; +typedef VkFlags VkSemaphoreCreateFlags; + +// Flag bits for VkEventCreateFlagBits +typedef VkFlags VkEventCreateFlagBits; +static constexpr VkEventCreateFlagBits VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR {0x00000001U}; + +typedef VkFlags VkEventCreateFlags; + +// Flag bits for VkQueryPipelineStatisticFlagBits +typedef VkFlags VkQueryPipelineStatisticFlagBits; +static constexpr VkQueryPipelineStatisticFlagBits VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT {0x00000001U}; +static constexpr VkQueryPipelineStatisticFlagBits VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT {0x00000002U}; +static constexpr VkQueryPipelineStatisticFlagBits VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT {0x00000004U}; +static constexpr VkQueryPipelineStatisticFlagBits VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT {0x00000008U}; +static constexpr VkQueryPipelineStatisticFlagBits VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT {0x00000010U}; +static constexpr VkQueryPipelineStatisticFlagBits VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT {0x00000020U}; +static constexpr VkQueryPipelineStatisticFlagBits VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT {0x00000040U}; +static constexpr VkQueryPipelineStatisticFlagBits VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT {0x00000080U}; +static constexpr VkQueryPipelineStatisticFlagBits VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT {0x00000100U}; +static constexpr VkQueryPipelineStatisticFlagBits VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT {0x00000200U}; +static constexpr VkQueryPipelineStatisticFlagBits VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT {0x00000400U}; + +typedef VkFlags VkQueryPipelineStatisticFlags; +typedef VkFlags VkQueryPoolCreateFlags; + +// Flag bits for VkQueryResultFlagBits +typedef VkFlags VkQueryResultFlagBits; +static constexpr VkQueryResultFlagBits VK_QUERY_RESULT_64_BIT {0x00000001U}; +static constexpr VkQueryResultFlagBits VK_QUERY_RESULT_WAIT_BIT {0x00000002U}; +static constexpr VkQueryResultFlagBits VK_QUERY_RESULT_WITH_AVAILABILITY_BIT {0x00000004U}; +static constexpr VkQueryResultFlagBits VK_QUERY_RESULT_PARTIAL_BIT {0x00000008U}; + +typedef VkFlags VkQueryResultFlags; + +// Flag bits for VkBufferCreateFlagBits +typedef VkFlags VkBufferCreateFlagBits; +static constexpr VkBufferCreateFlagBits VK_BUFFER_CREATE_SPARSE_BINDING_BIT {0x00000001U}; +static constexpr VkBufferCreateFlagBits VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT {0x00000002U}; +static constexpr VkBufferCreateFlagBits VK_BUFFER_CREATE_SPARSE_ALIASED_BIT {0x00000004U}; +static constexpr VkBufferCreateFlagBits VK_BUFFER_CREATE_PROTECTED_BIT {0x00000008U}; +static constexpr VkBufferCreateFlagBits VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT {0x00000010U}; + +typedef VkFlags VkBufferCreateFlags; + +// Flag bits for VkBufferUsageFlagBits +typedef VkFlags VkBufferUsageFlagBits; +static constexpr VkBufferUsageFlagBits VK_BUFFER_USAGE_TRANSFER_SRC_BIT {0x00000001U}; +static constexpr VkBufferUsageFlagBits VK_BUFFER_USAGE_TRANSFER_DST_BIT {0x00000002U}; +static constexpr VkBufferUsageFlagBits VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT {0x00000004U}; +static constexpr VkBufferUsageFlagBits VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT {0x00000008U}; +static constexpr VkBufferUsageFlagBits VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT {0x00000010U}; +static constexpr VkBufferUsageFlagBits VK_BUFFER_USAGE_STORAGE_BUFFER_BIT {0x00000020U}; +static constexpr VkBufferUsageFlagBits VK_BUFFER_USAGE_INDEX_BUFFER_BIT {0x00000040U}; +static constexpr VkBufferUsageFlagBits VK_BUFFER_USAGE_VERTEX_BUFFER_BIT {0x00000080U}; +static constexpr VkBufferUsageFlagBits VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT {0x00000100U}; +static constexpr VkBufferUsageFlagBits VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT {0x00020000U}; + +typedef VkFlags VkBufferUsageFlags; +typedef VkFlags VkBufferViewCreateFlags; + +// Flag bits for VkImageViewCreateFlagBits +typedef VkFlags VkImageViewCreateFlagBits; + +typedef VkFlags VkImageViewCreateFlags; + +// Flag bits for VkPipelineCacheCreateFlagBits +typedef VkFlags VkPipelineCacheCreateFlagBits; +static constexpr VkPipelineCacheCreateFlagBits VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT {0x00000004U}; +static constexpr VkPipelineCacheCreateFlagBits VK_PIPELINE_CACHE_CREATE_RESERVED_1_BIT_EXT {0x00000002U}; +static constexpr VkPipelineCacheCreateFlagBits VK_PIPELINE_CACHE_CREATE_READ_ONLY_BIT {VK_PIPELINE_CACHE_CREATE_RESERVED_1_BIT_EXT}; + +typedef VkFlags VkPipelineCacheCreateFlags; + +// Flag bits for VkColorComponentFlagBits +typedef VkFlags VkColorComponentFlagBits; +static constexpr VkColorComponentFlagBits VK_COLOR_COMPONENT_R_BIT {0x00000001U}; +static constexpr VkColorComponentFlagBits VK_COLOR_COMPONENT_G_BIT {0x00000002U}; +static constexpr VkColorComponentFlagBits VK_COLOR_COMPONENT_B_BIT {0x00000004U}; +static constexpr VkColorComponentFlagBits VK_COLOR_COMPONENT_A_BIT {0x00000008U}; + +typedef VkFlags VkColorComponentFlags; + +// Flag bits for VkPipelineCreateFlagBits +typedef VkFlags VkPipelineCreateFlagBits; +static constexpr VkPipelineCreateFlagBits VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT {0x00000001U}; +static constexpr VkPipelineCreateFlagBits VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT {0x00000008U}; +static constexpr VkPipelineCreateFlagBits VK_PIPELINE_CREATE_DISPATCH_BASE_BIT {0x00000010U}; +static constexpr VkPipelineCreateFlagBits VK_PIPELINE_CREATE_DISPATCH_BASE {VK_PIPELINE_CREATE_DISPATCH_BASE_BIT}; + +typedef VkFlags VkPipelineCreateFlags; + +// Flag bits for VkPipelineShaderStageCreateFlagBits +typedef VkFlags VkPipelineShaderStageCreateFlagBits; +static constexpr VkPipelineShaderStageCreateFlagBits VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT {0x00000001U}; +static constexpr VkPipelineShaderStageCreateFlagBits VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT {0x00000002U}; + +typedef VkFlags VkPipelineShaderStageCreateFlags; + +// Flag bits for VkShaderStageFlagBits +typedef VkFlags VkShaderStageFlagBits; +static constexpr VkShaderStageFlagBits VK_SHADER_STAGE_VERTEX_BIT {0x00000001U}; +static constexpr VkShaderStageFlagBits VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT {0x00000002U}; +static constexpr VkShaderStageFlagBits VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT {0x00000004U}; +static constexpr VkShaderStageFlagBits VK_SHADER_STAGE_GEOMETRY_BIT {0x00000008U}; +static constexpr VkShaderStageFlagBits VK_SHADER_STAGE_FRAGMENT_BIT {0x00000010U}; +static constexpr VkShaderStageFlagBits VK_SHADER_STAGE_COMPUTE_BIT {0x00000020U}; +static constexpr VkShaderStageFlagBits VK_SHADER_STAGE_ALL_GRAPHICS {0x0000001FU}; +static constexpr VkShaderStageFlagBits VK_SHADER_STAGE_ALL {0x7FFFFFFFU}; + + +// Flag bits for VkCullModeFlagBits +typedef VkFlags VkCullModeFlagBits; +static constexpr VkCullModeFlagBits VK_CULL_MODE_NONE {0U}; +static constexpr VkCullModeFlagBits VK_CULL_MODE_FRONT_BIT {0x00000001U}; +static constexpr VkCullModeFlagBits VK_CULL_MODE_BACK_BIT {0x00000002U}; +static constexpr VkCullModeFlagBits VK_CULL_MODE_FRONT_AND_BACK {0x00000003U}; + +typedef VkFlags VkCullModeFlags; +typedef VkFlags VkPipelineVertexInputStateCreateFlags; +typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; +typedef VkFlags VkPipelineTessellationStateCreateFlags; +typedef VkFlags VkPipelineViewportStateCreateFlags; +typedef VkFlags VkPipelineRasterizationStateCreateFlags; +typedef VkFlags VkPipelineMultisampleStateCreateFlags; +typedef VkFlags VkPipelineDepthStencilStateCreateFlags; +typedef VkFlags VkPipelineColorBlendStateCreateFlags; +typedef VkFlags VkPipelineDynamicStateCreateFlags; +typedef VkFlags VkPipelineLayoutCreateFlags; +typedef VkFlags VkShaderStageFlags; + +// Flag bits for VkSamplerCreateFlagBits +typedef VkFlags VkSamplerCreateFlagBits; + +typedef VkFlags VkSamplerCreateFlags; + +// Flag bits for VkDescriptorPoolCreateFlagBits +typedef VkFlags VkDescriptorPoolCreateFlagBits; +static constexpr VkDescriptorPoolCreateFlagBits VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT {0x00000001U}; +static constexpr VkDescriptorPoolCreateFlagBits VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT {0x00000002U}; + +typedef VkFlags VkDescriptorPoolCreateFlags; +typedef VkFlags VkDescriptorPoolResetFlags; + +// Flag bits for VkDescriptorSetLayoutCreateFlagBits +typedef VkFlags VkDescriptorSetLayoutCreateFlagBits; +static constexpr VkDescriptorSetLayoutCreateFlagBits VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT {0x00000002U}; + +typedef VkFlags VkDescriptorSetLayoutCreateFlags; + +// Flag bits for VkAttachmentDescriptionFlagBits +typedef VkFlags VkAttachmentDescriptionFlagBits; +static constexpr VkAttachmentDescriptionFlagBits VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT {0x00000001U}; + +typedef VkFlags VkAttachmentDescriptionFlags; + +// Flag bits for VkDependencyFlagBits +typedef VkFlags VkDependencyFlagBits; +static constexpr VkDependencyFlagBits VK_DEPENDENCY_BY_REGION_BIT {0x00000001U}; +static constexpr VkDependencyFlagBits VK_DEPENDENCY_DEVICE_GROUP_BIT {0x00000004U}; +static constexpr VkDependencyFlagBits VK_DEPENDENCY_VIEW_LOCAL_BIT {0x00000002U}; + +typedef VkFlags VkDependencyFlags; + +// Flag bits for VkFramebufferCreateFlagBits +typedef VkFlags VkFramebufferCreateFlagBits; +static constexpr VkFramebufferCreateFlagBits VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT {0x00000001U}; + +typedef VkFlags VkFramebufferCreateFlags; + +// Flag bits for VkRenderPassCreateFlagBits +typedef VkFlags VkRenderPassCreateFlagBits; + +typedef VkFlags VkRenderPassCreateFlags; + +// Flag bits for VkSubpassDescriptionFlagBits +typedef VkFlags VkSubpassDescriptionFlagBits; + +typedef VkFlags VkSubpassDescriptionFlags; + +// Flag bits for VkCommandPoolCreateFlagBits +typedef VkFlags VkCommandPoolCreateFlagBits; +static constexpr VkCommandPoolCreateFlagBits VK_COMMAND_POOL_CREATE_TRANSIENT_BIT {0x00000001U}; +static constexpr VkCommandPoolCreateFlagBits VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT {0x00000002U}; +static constexpr VkCommandPoolCreateFlagBits VK_COMMAND_POOL_CREATE_PROTECTED_BIT {0x00000004U}; + +typedef VkFlags VkCommandPoolCreateFlags; + +// Flag bits for VkCommandPoolResetFlagBits +typedef VkFlags VkCommandPoolResetFlagBits; + +typedef VkFlags VkCommandPoolResetFlags; + +// Flag bits for VkCommandBufferUsageFlagBits +typedef VkFlags VkCommandBufferUsageFlagBits; +static constexpr VkCommandBufferUsageFlagBits VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT {0x00000001U}; +static constexpr VkCommandBufferUsageFlagBits VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT {0x00000002U}; +static constexpr VkCommandBufferUsageFlagBits VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT {0x00000004U}; + +typedef VkFlags VkCommandBufferUsageFlags; + +// Flag bits for VkQueryControlFlagBits +typedef VkFlags VkQueryControlFlagBits; +static constexpr VkQueryControlFlagBits VK_QUERY_CONTROL_PRECISE_BIT {0x00000001U}; + +typedef VkFlags VkQueryControlFlags; + +// Flag bits for VkCommandBufferResetFlagBits +typedef VkFlags VkCommandBufferResetFlagBits; +static constexpr VkCommandBufferResetFlagBits VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT {0x00000001U}; + +typedef VkFlags VkCommandBufferResetFlags; + +// Flag bits for VkStencilFaceFlagBits +typedef VkFlags VkStencilFaceFlagBits; +static constexpr VkStencilFaceFlagBits VK_STENCIL_FACE_FRONT_BIT {0x00000001U}; +static constexpr VkStencilFaceFlagBits VK_STENCIL_FACE_BACK_BIT {0x00000002U}; +static constexpr VkStencilFaceFlagBits VK_STENCIL_FACE_FRONT_AND_BACK {0x00000003U}; + +typedef VkFlags VkStencilFaceFlags; +typedef struct VkExtent2D { + uint32_t width; + uint32_t height; +} VkExtent2D; + +typedef struct VkExtent3D { + uint32_t width; + uint32_t height; + uint32_t depth; +} VkExtent3D; + +typedef struct VkOffset2D { + int32_t x; + int32_t y; +} VkOffset2D; + +typedef struct VkOffset3D { + int32_t x; + int32_t y; + int32_t z; +} VkOffset3D; + +typedef struct VkRect2D { + VkOffset2D offset; + VkExtent2D extent; +} VkRect2D; + +typedef struct VkBaseInStructure { + VkStructureType sType; + struct VkBaseInStructure const* pNext; +} VkBaseInStructure; + +typedef struct VkBaseOutStructure { + VkStructureType sType; + struct VkBaseOutStructure* pNext; +} VkBaseOutStructure; + +typedef struct VkBufferMemoryBarrier { + VkStructureType sType; + void const* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} VkBufferMemoryBarrier; + +typedef struct VkDispatchIndirectCommand { + uint32_t x; + uint32_t y; + uint32_t z; +} VkDispatchIndirectCommand; + +typedef struct VkDrawIndexedIndirectCommand { + uint32_t indexCount; + uint32_t instanceCount; + uint32_t firstIndex; + int32_t vertexOffset; + uint32_t firstInstance; +} VkDrawIndexedIndirectCommand; + +typedef struct VkDrawIndirectCommand { + uint32_t vertexCount; + uint32_t instanceCount; + uint32_t firstVertex; + uint32_t firstInstance; +} VkDrawIndirectCommand; + +typedef struct VkImageSubresourceRange { + VkImageAspectFlags aspectMask; + uint32_t baseMipLevel; + uint32_t levelCount; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkImageSubresourceRange; + +typedef struct VkImageMemoryBarrier { + VkStructureType sType; + void const* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} VkImageMemoryBarrier; + +typedef struct VkMemoryBarrier { + VkStructureType sType; + void const* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; +} VkMemoryBarrier; + +typedef struct VkPipelineCacheHeaderVersionOne { + uint32_t headerSize; + VkPipelineCacheHeaderVersion headerVersion; + uint32_t vendorID; + uint32_t deviceID; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; +} VkPipelineCacheHeaderVersionOne; + +typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( + void* pUserData, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + +typedef void (VKAPI_PTR *PFN_vkFreeFunction)( + void* pUserData, + void* pMemory); + +typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + +typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + +typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( + void* pUserData, + void* pOriginal, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + +typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); +typedef struct VkAllocationCallbacks { + void* pUserData; + PFN_vkAllocationFunction pfnAllocation; + PFN_vkReallocationFunction pfnReallocation; + PFN_vkFreeFunction pfnFree; + PFN_vkInternalAllocationNotification pfnInternalAllocation; + PFN_vkInternalFreeNotification pfnInternalFree; +} VkAllocationCallbacks; + +typedef struct VkApplicationInfo { + VkStructureType sType; + void const* pNext; + char const* pApplicationName; + uint32_t applicationVersion; + char const* pEngineName; + uint32_t engineVersion; + uint32_t apiVersion; +} VkApplicationInfo; + +typedef struct VkFormatProperties { + VkFormatFeatureFlags linearTilingFeatures; + VkFormatFeatureFlags optimalTilingFeatures; + VkFormatFeatureFlags bufferFeatures; +} VkFormatProperties; + +typedef struct VkImageFormatProperties { + VkExtent3D maxExtent; + uint32_t maxMipLevels; + uint32_t maxArrayLayers; + VkSampleCountFlags sampleCounts; + VkDeviceSize maxResourceSize; +} VkImageFormatProperties; + +typedef struct VkInstanceCreateInfo { + VkStructureType sType; + void const* pNext; + VkInstanceCreateFlags flags; + VkApplicationInfo const* pApplicationInfo; + uint32_t enabledLayerCount; + char const* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + char const* const* ppEnabledExtensionNames; +} VkInstanceCreateInfo; + +typedef struct VkMemoryHeap { + VkDeviceSize size; + VkMemoryHeapFlags flags; +} VkMemoryHeap; + +typedef struct VkMemoryType { + VkMemoryPropertyFlags propertyFlags; + uint32_t heapIndex; +} VkMemoryType; + +typedef struct VkPhysicalDeviceFeatures { + VkBool32 robustBufferAccess; + VkBool32 fullDrawIndexUint32; + VkBool32 imageCubeArray; + VkBool32 independentBlend; + VkBool32 geometryShader; + VkBool32 tessellationShader; + VkBool32 sampleRateShading; + VkBool32 dualSrcBlend; + VkBool32 logicOp; + VkBool32 multiDrawIndirect; + VkBool32 drawIndirectFirstInstance; + VkBool32 depthClamp; + VkBool32 depthBiasClamp; + VkBool32 fillModeNonSolid; + VkBool32 depthBounds; + VkBool32 wideLines; + VkBool32 largePoints; + VkBool32 alphaToOne; + VkBool32 multiViewport; + VkBool32 samplerAnisotropy; + VkBool32 textureCompressionETC2; + VkBool32 textureCompressionASTC_LDR; + VkBool32 textureCompressionBC; + VkBool32 occlusionQueryPrecise; + VkBool32 pipelineStatisticsQuery; + VkBool32 vertexPipelineStoresAndAtomics; + VkBool32 fragmentStoresAndAtomics; + VkBool32 shaderTessellationAndGeometryPointSize; + VkBool32 shaderImageGatherExtended; + VkBool32 shaderStorageImageExtendedFormats; + VkBool32 shaderStorageImageMultisample; + VkBool32 shaderStorageImageReadWithoutFormat; + VkBool32 shaderStorageImageWriteWithoutFormat; + VkBool32 shaderUniformBufferArrayDynamicIndexing; + VkBool32 shaderSampledImageArrayDynamicIndexing; + VkBool32 shaderStorageBufferArrayDynamicIndexing; + VkBool32 shaderStorageImageArrayDynamicIndexing; + VkBool32 shaderClipDistance; + VkBool32 shaderCullDistance; + VkBool32 shaderFloat64; + VkBool32 shaderInt64; + VkBool32 shaderInt16; + VkBool32 shaderResourceResidency; + VkBool32 shaderResourceMinLod; + VkBool32 sparseBinding; + VkBool32 sparseResidencyBuffer; + VkBool32 sparseResidencyImage2D; + VkBool32 sparseResidencyImage3D; + VkBool32 sparseResidency2Samples; + VkBool32 sparseResidency4Samples; + VkBool32 sparseResidency8Samples; + VkBool32 sparseResidency16Samples; + VkBool32 sparseResidencyAliased; + VkBool32 variableMultisampleRate; + VkBool32 inheritedQueries; +} VkPhysicalDeviceFeatures; + +typedef struct VkPhysicalDeviceLimits { + uint32_t maxImageDimension1D; + uint32_t maxImageDimension2D; + uint32_t maxImageDimension3D; + uint32_t maxImageDimensionCube; + uint32_t maxImageArrayLayers; + uint32_t maxTexelBufferElements; + uint32_t maxUniformBufferRange; + uint32_t maxStorageBufferRange; + uint32_t maxPushConstantsSize; + uint32_t maxMemoryAllocationCount; + uint32_t maxSamplerAllocationCount; + VkDeviceSize bufferImageGranularity; + VkDeviceSize sparseAddressSpaceSize; + uint32_t maxBoundDescriptorSets; + uint32_t maxPerStageDescriptorSamplers; + uint32_t maxPerStageDescriptorUniformBuffers; + uint32_t maxPerStageDescriptorStorageBuffers; + uint32_t maxPerStageDescriptorSampledImages; + uint32_t maxPerStageDescriptorStorageImages; + uint32_t maxPerStageDescriptorInputAttachments; + uint32_t maxPerStageResources; + uint32_t maxDescriptorSetSamplers; + uint32_t maxDescriptorSetUniformBuffers; + uint32_t maxDescriptorSetUniformBuffersDynamic; + uint32_t maxDescriptorSetStorageBuffers; + uint32_t maxDescriptorSetStorageBuffersDynamic; + uint32_t maxDescriptorSetSampledImages; + uint32_t maxDescriptorSetStorageImages; + uint32_t maxDescriptorSetInputAttachments; + uint32_t maxVertexInputAttributes; + uint32_t maxVertexInputBindings; + uint32_t maxVertexInputAttributeOffset; + uint32_t maxVertexInputBindingStride; + uint32_t maxVertexOutputComponents; + uint32_t maxTessellationGenerationLevel; + uint32_t maxTessellationPatchSize; + uint32_t maxTessellationControlPerVertexInputComponents; + uint32_t maxTessellationControlPerVertexOutputComponents; + uint32_t maxTessellationControlPerPatchOutputComponents; + uint32_t maxTessellationControlTotalOutputComponents; + uint32_t maxTessellationEvaluationInputComponents; + uint32_t maxTessellationEvaluationOutputComponents; + uint32_t maxGeometryShaderInvocations; + uint32_t maxGeometryInputComponents; + uint32_t maxGeometryOutputComponents; + uint32_t maxGeometryOutputVertices; + uint32_t maxGeometryTotalOutputComponents; + uint32_t maxFragmentInputComponents; + uint32_t maxFragmentOutputAttachments; + uint32_t maxFragmentDualSrcAttachments; + uint32_t maxFragmentCombinedOutputResources; + uint32_t maxComputeSharedMemorySize; + uint32_t maxComputeWorkGroupCount[3]; + uint32_t maxComputeWorkGroupInvocations; + uint32_t maxComputeWorkGroupSize[3]; + uint32_t subPixelPrecisionBits; + uint32_t subTexelPrecisionBits; + uint32_t mipmapPrecisionBits; + uint32_t maxDrawIndexedIndexValue; + uint32_t maxDrawIndirectCount; + float maxSamplerLodBias; + float maxSamplerAnisotropy; + uint32_t maxViewports; + uint32_t maxViewportDimensions[2]; + float viewportBoundsRange[2]; + uint32_t viewportSubPixelBits; + size_t minMemoryMapAlignment; + VkDeviceSize minTexelBufferOffsetAlignment; + VkDeviceSize minUniformBufferOffsetAlignment; + VkDeviceSize minStorageBufferOffsetAlignment; + int32_t minTexelOffset; + uint32_t maxTexelOffset; + int32_t minTexelGatherOffset; + uint32_t maxTexelGatherOffset; + float minInterpolationOffset; + float maxInterpolationOffset; + uint32_t subPixelInterpolationOffsetBits; + uint32_t maxFramebufferWidth; + uint32_t maxFramebufferHeight; + uint32_t maxFramebufferLayers; + VkSampleCountFlags framebufferColorSampleCounts; + VkSampleCountFlags framebufferDepthSampleCounts; + VkSampleCountFlags framebufferStencilSampleCounts; + VkSampleCountFlags framebufferNoAttachmentsSampleCounts; + uint32_t maxColorAttachments; + VkSampleCountFlags sampledImageColorSampleCounts; + VkSampleCountFlags sampledImageIntegerSampleCounts; + VkSampleCountFlags sampledImageDepthSampleCounts; + VkSampleCountFlags sampledImageStencilSampleCounts; + VkSampleCountFlags storageImageSampleCounts; + uint32_t maxSampleMaskWords; + VkBool32 timestampComputeAndGraphics; + float timestampPeriod; + uint32_t maxClipDistances; + uint32_t maxCullDistances; + uint32_t maxCombinedClipAndCullDistances; + uint32_t discreteQueuePriorities; + float pointSizeRange[2]; + float lineWidthRange[2]; + float pointSizeGranularity; + float lineWidthGranularity; + VkBool32 strictLines; + VkBool32 standardSampleLocations; + VkDeviceSize optimalBufferCopyOffsetAlignment; + VkDeviceSize optimalBufferCopyRowPitchAlignment; + VkDeviceSize nonCoherentAtomSize; +} VkPhysicalDeviceLimits; + +typedef struct VkPhysicalDeviceMemoryProperties { + uint32_t memoryTypeCount; + VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; + uint32_t memoryHeapCount; + VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; +} VkPhysicalDeviceMemoryProperties; + +typedef struct VkPhysicalDeviceSparseProperties { + VkBool32 residencyStandard2DBlockShape; + VkBool32 residencyStandard2DMultisampleBlockShape; + VkBool32 residencyStandard3DBlockShape; + VkBool32 residencyAlignedMipSize; + VkBool32 residencyNonResidentStrict; +} VkPhysicalDeviceSparseProperties; + +typedef struct VkPhysicalDeviceProperties { + uint32_t apiVersion; + uint32_t driverVersion; + uint32_t vendorID; + uint32_t deviceID; + VkPhysicalDeviceType deviceType; + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; + VkPhysicalDeviceLimits limits; + VkPhysicalDeviceSparseProperties sparseProperties; +} VkPhysicalDeviceProperties; + +typedef struct VkQueueFamilyProperties { + VkQueueFlags queueFlags; + uint32_t queueCount; + uint32_t timestampValidBits; + VkExtent3D minImageTransferGranularity; +} VkQueueFamilyProperties; + +typedef struct VkDeviceQueueCreateInfo { + VkStructureType sType; + void const* pNext; + VkDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueCount; + float const* pQueuePriorities; +} VkDeviceQueueCreateInfo; + +typedef struct VkDeviceCreateInfo { + VkStructureType sType; + void const* pNext; + VkDeviceCreateFlags flags; + uint32_t queueCreateInfoCount; + VkDeviceQueueCreateInfo const* pQueueCreateInfos; + uint32_t enabledLayerCount; + char const* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + char const* const* ppEnabledExtensionNames; + VkPhysicalDeviceFeatures const* pEnabledFeatures; +} VkDeviceCreateInfo; + +typedef struct VkExtensionProperties { + char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; +} VkExtensionProperties; + +typedef struct VkLayerProperties { + char layerName[VK_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; + uint32_t implementationVersion; + char description[VK_MAX_DESCRIPTION_SIZE]; +} VkLayerProperties; + +typedef struct VkSubmitInfo { + VkStructureType sType; + void const* pNext; + uint32_t waitSemaphoreCount; + VkSemaphore const* pWaitSemaphores; + VkPipelineStageFlags const* pWaitDstStageMask; + uint32_t commandBufferCount; + VkCommandBuffer const* pCommandBuffers; + uint32_t signalSemaphoreCount; + VkSemaphore const* pSignalSemaphores; +} VkSubmitInfo; + +typedef struct VkMappedMemoryRange { + VkStructureType sType; + void const* pNext; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; +} VkMappedMemoryRange; + +typedef struct VkMemoryAllocateInfo { + VkStructureType sType; + void const* pNext; + VkDeviceSize allocationSize; + uint32_t memoryTypeIndex; +} VkMemoryAllocateInfo; + +typedef struct VkMemoryRequirements { + VkDeviceSize size; + VkDeviceSize alignment; + uint32_t memoryTypeBits; +} VkMemoryRequirements; + +typedef struct VkImageSubresource { + VkImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t arrayLayer; +} VkImageSubresource; + +typedef struct VkFenceCreateInfo { + VkStructureType sType; + void const* pNext; + VkFenceCreateFlags flags; +} VkFenceCreateInfo; + +typedef struct VkSemaphoreCreateInfo { + VkStructureType sType; + void const* pNext; + VkSemaphoreCreateFlags flags; +} VkSemaphoreCreateInfo; + +typedef struct VkEventCreateInfo { + VkStructureType sType; + void const* pNext; + VkEventCreateFlags flags; +} VkEventCreateInfo; + +typedef struct VkQueryPoolCreateInfo { + VkStructureType sType; + void const* pNext; + VkQueryPoolCreateFlags flags; + VkQueryType queryType; + uint32_t queryCount; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkQueryPoolCreateInfo; + +typedef struct VkBufferCreateInfo { + VkStructureType sType; + void const* pNext; + VkBufferCreateFlags flags; + VkDeviceSize size; + VkBufferUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + uint32_t const* pQueueFamilyIndices; +} VkBufferCreateInfo; + +typedef struct VkBufferViewCreateInfo { + VkStructureType sType; + void const* pNext; + VkBufferViewCreateFlags flags; + VkBuffer buffer; + VkFormat format; + VkDeviceSize offset; + VkDeviceSize range; +} VkBufferViewCreateInfo; + +typedef struct VkImageCreateInfo { + VkStructureType sType; + void const* pNext; + VkImageCreateFlags flags; + VkImageType imageType; + VkFormat format; + VkExtent3D extent; + uint32_t mipLevels; + uint32_t arrayLayers; + VkSampleCountFlagBits samples; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + uint32_t const* pQueueFamilyIndices; + VkImageLayout initialLayout; +} VkImageCreateInfo; + +typedef struct VkSubresourceLayout { + VkDeviceSize offset; + VkDeviceSize size; + VkDeviceSize rowPitch; + VkDeviceSize arrayPitch; + VkDeviceSize depthPitch; +} VkSubresourceLayout; + +typedef struct VkComponentMapping { + VkComponentSwizzle r; + VkComponentSwizzle g; + VkComponentSwizzle b; + VkComponentSwizzle a; +} VkComponentMapping; + +typedef struct VkImageViewCreateInfo { + VkStructureType sType; + void const* pNext; + VkImageViewCreateFlags flags; + VkImage image; + VkImageViewType viewType; + VkFormat format; + VkComponentMapping components; + VkImageSubresourceRange subresourceRange; +} VkImageViewCreateInfo; + +typedef struct VkPipelineCacheCreateInfo { + VkStructureType sType; + void const* pNext; + VkPipelineCacheCreateFlags flags; + size_t initialDataSize; + void const* pInitialData; +} VkPipelineCacheCreateInfo; + +typedef struct VkSpecializationMapEntry { + uint32_t constantID; + uint32_t offset; + size_t size; +} VkSpecializationMapEntry; + +typedef struct VkSpecializationInfo { + uint32_t mapEntryCount; + VkSpecializationMapEntry const* pMapEntries; + size_t dataSize; + void const* pData; +} VkSpecializationInfo; + +typedef struct VkPipelineShaderStageCreateInfo { + VkStructureType sType; + void const* pNext; + VkPipelineShaderStageCreateFlags flags; + VkShaderStageFlagBits stage; + VkShaderModule module; + char const* pName; + VkSpecializationInfo const* pSpecializationInfo; +} VkPipelineShaderStageCreateInfo; + +typedef struct VkComputePipelineCreateInfo { + VkStructureType sType; + void const* pNext; + VkPipelineCreateFlags flags; + VkPipelineShaderStageCreateInfo stage; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkComputePipelineCreateInfo; + +typedef struct VkVertexInputBindingDescription { + uint32_t binding; + uint32_t stride; + VkVertexInputRate inputRate; +} VkVertexInputBindingDescription; + +typedef struct VkVertexInputAttributeDescription { + uint32_t location; + uint32_t binding; + VkFormat format; + uint32_t offset; +} VkVertexInputAttributeDescription; + +typedef struct VkPipelineVertexInputStateCreateInfo { + VkStructureType sType; + void const* pNext; + VkPipelineVertexInputStateCreateFlags flags; + uint32_t vertexBindingDescriptionCount; + VkVertexInputBindingDescription const* pVertexBindingDescriptions; + uint32_t vertexAttributeDescriptionCount; + VkVertexInputAttributeDescription const* pVertexAttributeDescriptions; +} VkPipelineVertexInputStateCreateInfo; + +typedef struct VkPipelineInputAssemblyStateCreateInfo { + VkStructureType sType; + void const* pNext; + VkPipelineInputAssemblyStateCreateFlags flags; + VkPrimitiveTopology topology; + VkBool32 primitiveRestartEnable; +} VkPipelineInputAssemblyStateCreateInfo; + +typedef struct VkPipelineTessellationStateCreateInfo { + VkStructureType sType; + void const* pNext; + VkPipelineTessellationStateCreateFlags flags; + uint32_t patchControlPoints; +} VkPipelineTessellationStateCreateInfo; + +typedef struct VkViewport { + float x; + float y; + float width; + float height; + float minDepth; + float maxDepth; +} VkViewport; + +typedef struct VkPipelineViewportStateCreateInfo { + VkStructureType sType; + void const* pNext; + VkPipelineViewportStateCreateFlags flags; + uint32_t viewportCount; + VkViewport const* pViewports; + uint32_t scissorCount; + VkRect2D const* pScissors; +} VkPipelineViewportStateCreateInfo; + +typedef struct VkPipelineRasterizationStateCreateInfo { + VkStructureType sType; + void const* pNext; + VkPipelineRasterizationStateCreateFlags flags; + VkBool32 depthClampEnable; + VkBool32 rasterizerDiscardEnable; + VkPolygonMode polygonMode; + VkCullModeFlags cullMode; + VkFrontFace frontFace; + VkBool32 depthBiasEnable; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; + float lineWidth; +} VkPipelineRasterizationStateCreateInfo; + +typedef struct VkPipelineMultisampleStateCreateInfo { + VkStructureType sType; + void const* pNext; + VkPipelineMultisampleStateCreateFlags flags; + VkSampleCountFlagBits rasterizationSamples; + VkBool32 sampleShadingEnable; + float minSampleShading; + VkSampleMask const* pSampleMask; + VkBool32 alphaToCoverageEnable; + VkBool32 alphaToOneEnable; +} VkPipelineMultisampleStateCreateInfo; + +typedef struct VkStencilOpState { + VkStencilOp failOp; + VkStencilOp passOp; + VkStencilOp depthFailOp; + VkCompareOp compareOp; + uint32_t compareMask; + uint32_t writeMask; + uint32_t reference; +} VkStencilOpState; + +typedef struct VkPipelineDepthStencilStateCreateInfo { + VkStructureType sType; + void const* pNext; + VkPipelineDepthStencilStateCreateFlags flags; + VkBool32 depthTestEnable; + VkBool32 depthWriteEnable; + VkCompareOp depthCompareOp; + VkBool32 depthBoundsTestEnable; + VkBool32 stencilTestEnable; + VkStencilOpState front; + VkStencilOpState back; + float minDepthBounds; + float maxDepthBounds; +} VkPipelineDepthStencilStateCreateInfo; + +typedef struct VkPipelineColorBlendAttachmentState { + VkBool32 blendEnable; + VkBlendFactor srcColorBlendFactor; + VkBlendFactor dstColorBlendFactor; + VkBlendOp colorBlendOp; + VkBlendFactor srcAlphaBlendFactor; + VkBlendFactor dstAlphaBlendFactor; + VkBlendOp alphaBlendOp; + VkColorComponentFlags colorWriteMask; +} VkPipelineColorBlendAttachmentState; + +typedef struct VkPipelineColorBlendStateCreateInfo { + VkStructureType sType; + void const* pNext; + VkPipelineColorBlendStateCreateFlags flags; + VkBool32 logicOpEnable; + VkLogicOp logicOp; + uint32_t attachmentCount; + VkPipelineColorBlendAttachmentState const* pAttachments; + float blendConstants[4]; +} VkPipelineColorBlendStateCreateInfo; + +typedef struct VkPipelineDynamicStateCreateInfo { + VkStructureType sType; + void const* pNext; + VkPipelineDynamicStateCreateFlags flags; + uint32_t dynamicStateCount; + VkDynamicState const* pDynamicStates; +} VkPipelineDynamicStateCreateInfo; + +typedef struct VkGraphicsPipelineCreateInfo { + VkStructureType sType; + void const* pNext; + VkPipelineCreateFlags flags; + uint32_t stageCount; + VkPipelineShaderStageCreateInfo const* pStages; + VkPipelineVertexInputStateCreateInfo const* pVertexInputState; + VkPipelineInputAssemblyStateCreateInfo const* pInputAssemblyState; + VkPipelineTessellationStateCreateInfo const* pTessellationState; + VkPipelineViewportStateCreateInfo const* pViewportState; + VkPipelineRasterizationStateCreateInfo const* pRasterizationState; + VkPipelineMultisampleStateCreateInfo const* pMultisampleState; + VkPipelineDepthStencilStateCreateInfo const* pDepthStencilState; + VkPipelineColorBlendStateCreateInfo const* pColorBlendState; + VkPipelineDynamicStateCreateInfo const* pDynamicState; + VkPipelineLayout layout; + VkRenderPass renderPass; + uint32_t subpass; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkGraphicsPipelineCreateInfo; + +typedef struct VkPushConstantRange { + VkShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; +} VkPushConstantRange; + +typedef struct VkPipelineLayoutCreateInfo { + VkStructureType sType; + void const* pNext; + VkPipelineLayoutCreateFlags flags; + uint32_t setLayoutCount; + VkDescriptorSetLayout const* pSetLayouts; + uint32_t pushConstantRangeCount; + VkPushConstantRange const* pPushConstantRanges; +} VkPipelineLayoutCreateInfo; + +typedef struct VkSamplerCreateInfo { + VkStructureType sType; + void const* pNext; + VkSamplerCreateFlags flags; + VkFilter magFilter; + VkFilter minFilter; + VkSamplerMipmapMode mipmapMode; + VkSamplerAddressMode addressModeU; + VkSamplerAddressMode addressModeV; + VkSamplerAddressMode addressModeW; + float mipLodBias; + VkBool32 anisotropyEnable; + float maxAnisotropy; + VkBool32 compareEnable; + VkCompareOp compareOp; + float minLod; + float maxLod; + VkBorderColor borderColor; + VkBool32 unnormalizedCoordinates; +} VkSamplerCreateInfo; + +typedef struct VkCopyDescriptorSet { + VkStructureType sType; + void const* pNext; + VkDescriptorSet srcSet; + uint32_t srcBinding; + uint32_t srcArrayElement; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; +} VkCopyDescriptorSet; + +typedef struct VkDescriptorBufferInfo { + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize range; +} VkDescriptorBufferInfo; + +typedef struct VkDescriptorImageInfo { + VkSampler sampler; + VkImageView imageView; + VkImageLayout imageLayout; +} VkDescriptorImageInfo; + +typedef struct VkDescriptorPoolSize { + VkDescriptorType type; + uint32_t descriptorCount; +} VkDescriptorPoolSize; + +typedef struct VkDescriptorPoolCreateInfo { + VkStructureType sType; + void const* pNext; + VkDescriptorPoolCreateFlags flags; + uint32_t maxSets; + uint32_t poolSizeCount; + VkDescriptorPoolSize const* pPoolSizes; +} VkDescriptorPoolCreateInfo; + +typedef struct VkDescriptorSetAllocateInfo { + VkStructureType sType; + void const* pNext; + VkDescriptorPool descriptorPool; + uint32_t descriptorSetCount; + VkDescriptorSetLayout const* pSetLayouts; +} VkDescriptorSetAllocateInfo; + +typedef struct VkDescriptorSetLayoutBinding { + uint32_t binding; + VkDescriptorType descriptorType; + uint32_t descriptorCount; + VkShaderStageFlags stageFlags; + VkSampler const* pImmutableSamplers; +} VkDescriptorSetLayoutBinding; + +typedef struct VkDescriptorSetLayoutCreateInfo { + VkStructureType sType; + void const* pNext; + VkDescriptorSetLayoutCreateFlags flags; + uint32_t bindingCount; + VkDescriptorSetLayoutBinding const* pBindings; +} VkDescriptorSetLayoutCreateInfo; + +typedef struct VkWriteDescriptorSet { + VkStructureType sType; + void const* pNext; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + VkDescriptorImageInfo const* pImageInfo; + VkDescriptorBufferInfo const* pBufferInfo; + VkBufferView const* pTexelBufferView; +} VkWriteDescriptorSet; + +typedef struct VkAttachmentDescription { + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription; + +typedef struct VkAttachmentReference { + uint32_t attachment; + VkImageLayout layout; +} VkAttachmentReference; + +typedef struct VkFramebufferCreateInfo { + VkStructureType sType; + void const* pNext; + VkFramebufferCreateFlags flags; + VkRenderPass renderPass; + uint32_t attachmentCount; + VkImageView const* pAttachments; + uint32_t width; + uint32_t height; + uint32_t layers; +} VkFramebufferCreateInfo; + +typedef struct VkSubpassDescription { + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t inputAttachmentCount; + VkAttachmentReference const* pInputAttachments; + uint32_t colorAttachmentCount; + VkAttachmentReference const* pColorAttachments; + VkAttachmentReference const* pResolveAttachments; + VkAttachmentReference const* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + uint32_t const* pPreserveAttachments; +} VkSubpassDescription; + +typedef struct VkSubpassDependency { + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; +} VkSubpassDependency; + +typedef struct VkRenderPassCreateInfo { + VkStructureType sType; + void const* pNext; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + VkAttachmentDescription const* pAttachments; + uint32_t subpassCount; + VkSubpassDescription const* pSubpasses; + uint32_t dependencyCount; + VkSubpassDependency const* pDependencies; +} VkRenderPassCreateInfo; + +typedef struct VkCommandPoolCreateInfo { + VkStructureType sType; + void const* pNext; + VkCommandPoolCreateFlags flags; + uint32_t queueFamilyIndex; +} VkCommandPoolCreateInfo; + +typedef struct VkCommandBufferAllocateInfo { + VkStructureType sType; + void const* pNext; + VkCommandPool commandPool; + VkCommandBufferLevel level; + uint32_t commandBufferCount; +} VkCommandBufferAllocateInfo; + +typedef struct VkCommandBufferInheritanceInfo { + VkStructureType sType; + void const* pNext; + VkRenderPass renderPass; + uint32_t subpass; + VkFramebuffer framebuffer; + VkBool32 occlusionQueryEnable; + VkQueryControlFlags queryFlags; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkCommandBufferInheritanceInfo; + +typedef struct VkCommandBufferBeginInfo { + VkStructureType sType; + void const* pNext; + VkCommandBufferUsageFlags flags; + VkCommandBufferInheritanceInfo const* pInheritanceInfo; +} VkCommandBufferBeginInfo; + +typedef struct VkBufferCopy { + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; +} VkBufferCopy; + +typedef struct VkImageSubresourceLayers { + VkImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkImageSubresourceLayers; + +typedef struct VkBufferImageCopy { + VkDeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy; + +typedef union VkClearColorValue { + float float32[4]; + int32_t int32[4]; + uint32_t uint32[4]; +} VkClearColorValue; + +typedef struct VkClearDepthStencilValue { + float depth; + uint32_t stencil; +} VkClearDepthStencilValue; + +typedef union VkClearValue { + VkClearColorValue color; + VkClearDepthStencilValue depthStencil; +} VkClearValue; + +typedef struct VkClearAttachment { + VkImageAspectFlags aspectMask; + uint32_t colorAttachment; + VkClearValue clearValue; +} VkClearAttachment; + +typedef struct VkClearRect { + VkRect2D rect; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkClearRect; + +typedef struct VkImageBlit { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffsets[2]; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffsets[2]; +} VkImageBlit; + +typedef struct VkImageCopy { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageCopy; + +typedef struct VkImageResolve { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageResolve; + +typedef struct VkRenderPassBeginInfo { + VkStructureType sType; + void const* pNext; + VkRenderPass renderPass; + VkFramebuffer framebuffer; + VkRect2D renderArea; + uint32_t clearValueCount; + VkClearValue const* pClearValues; +} VkRenderPassBeginInfo; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(VkInstanceCreateInfo const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkInstance* pInstance); +typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, VkAllocationCallbacks const * pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, char const * pName); +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, char const * pName); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, VkDeviceCreateInfo const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkDevice* pDevice); +typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, VkAllocationCallbacks const * pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(char const * pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, char const * pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); +typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, VkSubmitInfo const * pSubmits, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue); +typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, VkMemoryAllocateInfo const * pAllocateInfo, VkAllocationCallbacks const * pAllocator, VkDeviceMemory* pMemory); +typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); +typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory); +typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, VkMappedMemoryRange const * pMemoryRanges); +typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, VkMappedMemoryRange const * pMemoryRanges); +typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); +typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, VkFenceCreateInfo const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkFence* pFence); +typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, VkAllocationCallbacks const * pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, VkFence const * pFences); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, VkFence const * pFences, VkBool32 waitAll, uint64_t timeout); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, VkSemaphoreCreateInfo const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkSemaphore* pSemaphore); +typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, VkAllocationCallbacks const * pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, VkEventCreateInfo const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkEvent* pEvent); +typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, VkAllocationCallbacks const * pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, VkQueryPoolCreateInfo const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkQueryPool* pQueryPool); +typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, VkBufferCreateInfo const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkBuffer* pBuffer); +typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, VkAllocationCallbacks const * pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, VkBufferViewCreateInfo const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkBufferView* pView); +typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, VkAllocationCallbacks const * pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, VkImageCreateInfo const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkImage* pImage); +typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, VkAllocationCallbacks const * pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, VkImageSubresource const * pSubresource, VkSubresourceLayout* pLayout); +typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, VkImageViewCreateInfo const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkImageView* pView); +typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, VkAllocationCallbacks const * pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, VkPipelineCacheCreateInfo const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkPipelineCache* pPipelineCache); +typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, VkAllocationCallbacks const * pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, VkGraphicsPipelineCreateInfo const * pCreateInfos, VkAllocationCallbacks const * pAllocator, VkPipeline* pPipelines); +typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, VkComputePipelineCreateInfo const * pCreateInfos, VkAllocationCallbacks const * pAllocator, VkPipeline* pPipelines); +typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, VkAllocationCallbacks const * pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, VkPipelineLayoutCreateInfo const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkPipelineLayout* pPipelineLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, VkAllocationCallbacks const * pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, VkSamplerCreateInfo const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkSampler* pSampler); +typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, VkAllocationCallbacks const * pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayoutCreateInfo const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkDescriptorSetLayout* pSetLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, VkAllocationCallbacks const * pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, VkDescriptorPoolCreateInfo const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkDescriptorPool* pDescriptorPool); +typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, VkDescriptorSetAllocateInfo const * pAllocateInfo, VkDescriptorSet* pDescriptorSets); +typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, VkDescriptorSet const * pDescriptorSets); +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, VkWriteDescriptorSet const * pDescriptorWrites, uint32_t descriptorCopyCount, VkCopyDescriptorSet const * pDescriptorCopies); +typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, VkFramebufferCreateInfo const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkFramebuffer* pFramebuffer); +typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, VkAllocationCallbacks const * pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, VkRenderPassCreateInfo const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkRenderPass* pRenderPass); +typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, VkAllocationCallbacks const * pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); +typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, VkCommandPoolCreateInfo const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkCommandPool* pCommandPool); +typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, VkCommandBufferAllocateInfo const * pAllocateInfo, VkCommandBuffer* pCommandBuffers); +typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, VkCommandBuffer const * pCommandBuffers); +typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferBeginInfo const * pBeginInfo); +typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); +typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, VkViewport const * pViewports); +typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, VkRect2D const * pScissors); +typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); +typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, float const blendConstants[4]); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, VkDescriptorSet const * pDescriptorSets, uint32_t dynamicOffsetCount, uint32_t const * pDynamicOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); +typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, VkBuffer const * pBuffers, VkDeviceSize const * pOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, VkBufferCopy const * pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, VkImageCopy const * pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, VkImageBlit const * pRegions, VkFilter filter); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, VkBufferImageCopy const * pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, VkBufferImageCopy const * pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, void const * pData); +typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); +typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearColorValue const * pColor, uint32_t rangeCount, VkImageSubresourceRange const * pRanges); +typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearDepthStencilValue const * pDepthStencil, uint32_t rangeCount, VkImageSubresourceRange const * pRanges); +typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, VkClearAttachment const * pAttachments, uint32_t rectCount, VkClearRect const * pRects); +typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, VkImageResolve const * pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, VkEvent const * pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, VkMemoryBarrier const * pMemoryBarriers, uint32_t bufferMemoryBarrierCount, VkBufferMemoryBarrier const * pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, VkImageMemoryBarrier const * pImageMemoryBarriers); +typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, VkMemoryBarrier const * pMemoryBarriers, uint32_t bufferMemoryBarrierCount, VkBufferMemoryBarrier const * pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, VkImageMemoryBarrier const * pImageMemoryBarriers); +typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); +typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); +typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, void const * pValues); +typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, VkRenderPassBeginInfo const * pRenderPassBegin, VkSubpassContents contents); +typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents); +typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, VkCommandBuffer const * pCommandBuffers); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( + VkInstanceCreateInfo const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkInstance* pInstance); + +VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( + VkInstance instance, + VkAllocationCallbacks const* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( + VkInstance instance, + uint32_t* pPhysicalDeviceCount, + VkPhysicalDevice* pPhysicalDevices); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures* pFeatures); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties* pFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkImageFormatProperties* pImageFormatProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties* pQueueFamilyProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties* pMemoryProperties); + +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr( + VkInstance instance, + char const* pName); + +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr( + VkDevice device, + char const* pName); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( + VkPhysicalDevice physicalDevice, + VkDeviceCreateInfo const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkDevice* pDevice); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( + VkDevice device, + VkAllocationCallbacks const* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( + char const* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( + VkPhysicalDevice physicalDevice, + char const* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( + uint32_t* pPropertyCount, + VkLayerProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkLayerProperties* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( + VkDevice device, + uint32_t queueFamilyIndex, + uint32_t queueIndex, + VkQueue* pQueue); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( + VkQueue queue, + uint32_t submitCount, + VkSubmitInfo const* pSubmits, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle( + VkQueue queue); + +VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle( + VkDevice device); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory( + VkDevice device, + VkMemoryAllocateInfo const* pAllocateInfo, + VkAllocationCallbacks const* pAllocator, + VkDeviceMemory* pMemory); + +VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize offset, + VkDeviceSize size, + VkMemoryMapFlags flags, + void** ppData); + +VKAPI_ATTR void VKAPI_CALL vkUnmapMemory( + VkDevice device, + VkDeviceMemory memory); + +VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + VkMappedMemoryRange const* pMemoryRanges); + +VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + VkMappedMemoryRange const* pMemoryRanges); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize* pCommittedMemoryInBytes); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory( + VkDevice device, + VkBuffer buffer, + VkDeviceMemory memory, + VkDeviceSize memoryOffset); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory( + VkDevice device, + VkImage image, + VkDeviceMemory memory, + VkDeviceSize memoryOffset); + +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements( + VkDevice device, + VkBuffer buffer, + VkMemoryRequirements* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements( + VkDevice device, + VkImage image, + VkMemoryRequirements* pMemoryRequirements); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence( + VkDevice device, + VkFenceCreateInfo const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkFence* pFence); + +VKAPI_ATTR void VKAPI_CALL vkDestroyFence( + VkDevice device, + VkFence fence, + VkAllocationCallbacks const* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetFences( + VkDevice device, + uint32_t fenceCount, + VkFence const* pFences); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus( + VkDevice device, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences( + VkDevice device, + uint32_t fenceCount, + VkFence const* pFences, + VkBool32 waitAll, + uint64_t timeout); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore( + VkDevice device, + VkSemaphoreCreateInfo const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkSemaphore* pSemaphore); + +VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( + VkDevice device, + VkSemaphore semaphore, + VkAllocationCallbacks const* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( + VkDevice device, + VkEventCreateInfo const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkEvent* pEvent); + +VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( + VkDevice device, + VkEvent event, + VkAllocationCallbacks const* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool( + VkDevice device, + VkQueryPoolCreateInfo const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkQueryPool* pQueryPool); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + size_t dataSize, + void* pData, + VkDeviceSize stride, + VkQueryResultFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer( + VkDevice device, + VkBufferCreateInfo const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkBuffer* pBuffer); + +VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer( + VkDevice device, + VkBuffer buffer, + VkAllocationCallbacks const* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView( + VkDevice device, + VkBufferViewCreateInfo const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkBufferView* pView); + +VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView( + VkDevice device, + VkBufferView bufferView, + VkAllocationCallbacks const* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage( + VkDevice device, + VkImageCreateInfo const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkImage* pImage); + +VKAPI_ATTR void VKAPI_CALL vkDestroyImage( + VkDevice device, + VkImage image, + VkAllocationCallbacks const* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( + VkDevice device, + VkImage image, + VkImageSubresource const* pSubresource, + VkSubresourceLayout* pLayout); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView( + VkDevice device, + VkImageViewCreateInfo const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkImageView* pView); + +VKAPI_ATTR void VKAPI_CALL vkDestroyImageView( + VkDevice device, + VkImageView imageView, + VkAllocationCallbacks const* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache( + VkDevice device, + VkPipelineCacheCreateInfo const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkPipelineCache* pPipelineCache); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache( + VkDevice device, + VkPipelineCache pipelineCache, + VkAllocationCallbacks const* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + VkGraphicsPipelineCreateInfo const* pCreateInfos, + VkAllocationCallbacks const* pAllocator, + VkPipeline* pPipelines); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + VkComputePipelineCreateInfo const* pCreateInfos, + VkAllocationCallbacks const* pAllocator, + VkPipeline* pPipelines); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline( + VkDevice device, + VkPipeline pipeline, + VkAllocationCallbacks const* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout( + VkDevice device, + VkPipelineLayoutCreateInfo const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkPipelineLayout* pPipelineLayout); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout( + VkDevice device, + VkPipelineLayout pipelineLayout, + VkAllocationCallbacks const* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler( + VkDevice device, + VkSamplerCreateInfo const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkSampler* pSampler); + +VKAPI_ATTR void VKAPI_CALL vkDestroySampler( + VkDevice device, + VkSampler sampler, + VkAllocationCallbacks const* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout( + VkDevice device, + VkDescriptorSetLayoutCreateInfo const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkDescriptorSetLayout* pSetLayout); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout( + VkDevice device, + VkDescriptorSetLayout descriptorSetLayout, + VkAllocationCallbacks const* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool( + VkDevice device, + VkDescriptorPoolCreateInfo const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkDescriptorPool* pDescriptorPool); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + VkDescriptorPoolResetFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets( + VkDevice device, + VkDescriptorSetAllocateInfo const* pAllocateInfo, + VkDescriptorSet* pDescriptorSets); + +VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets( + VkDevice device, + VkDescriptorPool descriptorPool, + uint32_t descriptorSetCount, + VkDescriptorSet const* pDescriptorSets); + +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( + VkDevice device, + uint32_t descriptorWriteCount, + VkWriteDescriptorSet const* pDescriptorWrites, + uint32_t descriptorCopyCount, + VkCopyDescriptorSet const* pDescriptorCopies); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( + VkDevice device, + VkFramebufferCreateInfo const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkFramebuffer* pFramebuffer); + +VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer( + VkDevice device, + VkFramebuffer framebuffer, + VkAllocationCallbacks const* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( + VkDevice device, + VkRenderPassCreateInfo const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkRenderPass* pRenderPass); + +VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass( + VkDevice device, + VkRenderPass renderPass, + VkAllocationCallbacks const* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity( + VkDevice device, + VkRenderPass renderPass, + VkExtent2D* pGranularity); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( + VkDevice device, + VkCommandPoolCreateInfo const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkCommandPool* pCommandPool); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolResetFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( + VkDevice device, + VkCommandBufferAllocateInfo const* pAllocateInfo, + VkCommandBuffer* pCommandBuffers); + +VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( + VkDevice device, + VkCommandPool commandPool, + uint32_t commandBufferCount, + VkCommandBuffer const* pCommandBuffers); + +VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( + VkCommandBuffer commandBuffer, + VkCommandBufferBeginInfo const* pBeginInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( + VkCommandBuffer commandBuffer, + VkCommandBufferResetFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + VkViewport const* pViewports); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor( + VkCommandBuffer commandBuffer, + uint32_t firstScissor, + uint32_t scissorCount, + VkRect2D const* pScissors); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth( + VkCommandBuffer commandBuffer, + float lineWidth); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias( + VkCommandBuffer commandBuffer, + float depthBiasConstantFactor, + float depthBiasClamp, + float depthBiasSlopeFactor); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants( + VkCommandBuffer commandBuffer, + float const blendConstants[4]); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds( + VkCommandBuffer commandBuffer, + float minDepthBounds, + float maxDepthBounds); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t compareMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t writeMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t reference); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t descriptorSetCount, + VkDescriptorSet const* pDescriptorSets, + uint32_t dynamicOffsetCount, + uint32_t const* pDynamicOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkIndexType indexType); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + VkBuffer const* pBuffers, + VkDeviceSize const* pOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdDraw( + VkCommandBuffer commandBuffer, + uint32_t vertexCount, + uint32_t instanceCount, + uint32_t firstVertex, + uint32_t firstInstance); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed( + VkCommandBuffer commandBuffer, + uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, + int32_t vertexOffset, + uint32_t firstInstance); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkBuffer dstBuffer, + uint32_t regionCount, + VkBufferCopy const* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + VkImageCopy const* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + VkImageBlit const* pRegions, + VkFilter filter); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + VkBufferImageCopy const* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer dstBuffer, + uint32_t regionCount, + VkBufferImageCopy const* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize dataSize, + void const* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize size, + uint32_t data); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + VkClearColorValue const* pColor, + uint32_t rangeCount, + VkImageSubresourceRange const* pRanges); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + VkClearDepthStencilValue const* pDepthStencil, + uint32_t rangeCount, + VkImageSubresourceRange const* pRanges); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + VkClearAttachment const* pAttachments, + uint32_t rectCount, + VkClearRect const* pRects); + +VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + VkImageResolve const* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + VkEvent const* pEvents, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + uint32_t memoryBarrierCount, + VkMemoryBarrier const* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + VkBufferMemoryBarrier const* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + VkImageMemoryBarrier const* pImageMemoryBarriers); + +VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + VkDependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, + VkMemoryBarrier const* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + VkBufferMemoryBarrier const* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + VkImageMemoryBarrier const* pImageMemoryBarriers); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize stride, + VkQueryResultFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( + VkCommandBuffer commandBuffer, + VkPipelineLayout layout, + VkShaderStageFlags stageFlags, + uint32_t offset, + uint32_t size, + void const* pValues); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( + VkCommandBuffer commandBuffer, + VkRenderPassBeginInfo const* pRenderPassBegin, + VkSubpassContents contents); + +VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass( + VkCommandBuffer commandBuffer, + VkSubpassContents contents); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( + VkCommandBuffer commandBuffer, + uint32_t commandBufferCount, + VkCommandBuffer const* pCommandBuffers); +#endif + + +#define VK_VERSION_1_1 1 +// Vulkan 1.1 version number +#define VK_API_VERSION_1_1 VK_MAKE_API_VERSION(0, 1, 1, 0)// Patch version should always be set to 0 + +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion) +static constexpr uint32_t VK_MAX_DEVICE_GROUP_SIZE {static_cast(32U)}; +static constexpr uint32_t VK_LUID_SIZE {static_cast(8U)}; +static constexpr uint32_t VK_QUEUE_FAMILY_EXTERNAL {~static_cast(1U)}; + +typedef enum VkPointClippingBehavior { + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, + VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF +} VkPointClippingBehavior; + +typedef enum VkTessellationDomainOrigin { + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, + VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF +} VkTessellationDomainOrigin; + +typedef enum VkSamplerYcbcrModelConversion { + VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF +} VkSamplerYcbcrModelConversion; + +typedef enum VkSamplerYcbcrRange { + VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, + VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1, + VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerYcbcrRange; + +typedef enum VkChromaLocation { + VK_CHROMA_LOCATION_COSITED_EVEN = 0, + VK_CHROMA_LOCATION_MIDPOINT = 1, + VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF +} VkChromaLocation; + +// Flag bits for VkSubgroupFeatureFlagBits +typedef VkFlags VkSubgroupFeatureFlagBits; +static constexpr VkSubgroupFeatureFlagBits VK_SUBGROUP_FEATURE_BASIC_BIT {0x00000001U}; +static constexpr VkSubgroupFeatureFlagBits VK_SUBGROUP_FEATURE_VOTE_BIT {0x00000002U}; +static constexpr VkSubgroupFeatureFlagBits VK_SUBGROUP_FEATURE_ARITHMETIC_BIT {0x00000004U}; +static constexpr VkSubgroupFeatureFlagBits VK_SUBGROUP_FEATURE_BALLOT_BIT {0x00000008U}; +static constexpr VkSubgroupFeatureFlagBits VK_SUBGROUP_FEATURE_SHUFFLE_BIT {0x00000010U}; +static constexpr VkSubgroupFeatureFlagBits VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT {0x00000020U}; +static constexpr VkSubgroupFeatureFlagBits VK_SUBGROUP_FEATURE_CLUSTERED_BIT {0x00000040U}; +static constexpr VkSubgroupFeatureFlagBits VK_SUBGROUP_FEATURE_QUAD_BIT {0x00000080U}; + +typedef VkFlags VkSubgroupFeatureFlags; + +// Flag bits for VkPeerMemoryFeatureFlagBits +typedef VkFlags VkPeerMemoryFeatureFlagBits; +static constexpr VkPeerMemoryFeatureFlagBits VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT {0x00000001U}; +static constexpr VkPeerMemoryFeatureFlagBits VK_PEER_MEMORY_FEATURE_COPY_DST_BIT {0x00000002U}; +static constexpr VkPeerMemoryFeatureFlagBits VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT {0x00000004U}; +static constexpr VkPeerMemoryFeatureFlagBits VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT {0x00000008U}; + +typedef VkFlags VkPeerMemoryFeatureFlags; + +// Flag bits for VkMemoryAllocateFlagBits +typedef VkFlags VkMemoryAllocateFlagBits; +static constexpr VkMemoryAllocateFlagBits VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT {0x00000001U}; +static constexpr VkMemoryAllocateFlagBits VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT {0x00000002U}; +static constexpr VkMemoryAllocateFlagBits VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT {0x00000004U}; + +typedef VkFlags VkMemoryAllocateFlags; + +// Flag bits for VkExternalMemoryHandleTypeFlagBits +typedef VkFlags VkExternalMemoryHandleTypeFlagBits; +static constexpr VkExternalMemoryHandleTypeFlagBits VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT {0x00000001U}; +static constexpr VkExternalMemoryHandleTypeFlagBits VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT {0x00000002U}; +static constexpr VkExternalMemoryHandleTypeFlagBits VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT {0x00000004U}; +static constexpr VkExternalMemoryHandleTypeFlagBits VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT {0x00000008U}; +static constexpr VkExternalMemoryHandleTypeFlagBits VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT {0x00000010U}; +static constexpr VkExternalMemoryHandleTypeFlagBits VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT {0x00000020U}; +static constexpr VkExternalMemoryHandleTypeFlagBits VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT {0x00000040U}; +static constexpr VkExternalMemoryHandleTypeFlagBits VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT {0x00000200U}; +static constexpr VkExternalMemoryHandleTypeFlagBits VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT {0x00000080U}; +static constexpr VkExternalMemoryHandleTypeFlagBits VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT {0x00000100U}; + +typedef VkFlags VkExternalMemoryHandleTypeFlags; + +// Flag bits for VkExternalMemoryFeatureFlagBits +typedef VkFlags VkExternalMemoryFeatureFlagBits; +static constexpr VkExternalMemoryFeatureFlagBits VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT {0x00000001U}; +static constexpr VkExternalMemoryFeatureFlagBits VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT {0x00000002U}; +static constexpr VkExternalMemoryFeatureFlagBits VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT {0x00000004U}; + +typedef VkFlags VkExternalMemoryFeatureFlags; + +// Flag bits for VkExternalFenceHandleTypeFlagBits +typedef VkFlags VkExternalFenceHandleTypeFlagBits; +static constexpr VkExternalFenceHandleTypeFlagBits VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT {0x00000001U}; +static constexpr VkExternalFenceHandleTypeFlagBits VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT {0x00000002U}; +static constexpr VkExternalFenceHandleTypeFlagBits VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT {0x00000004U}; +static constexpr VkExternalFenceHandleTypeFlagBits VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT {0x00000008U}; + +typedef VkFlags VkExternalFenceHandleTypeFlags; + +// Flag bits for VkExternalFenceFeatureFlagBits +typedef VkFlags VkExternalFenceFeatureFlagBits; +static constexpr VkExternalFenceFeatureFlagBits VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT {0x00000001U}; +static constexpr VkExternalFenceFeatureFlagBits VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT {0x00000002U}; + +typedef VkFlags VkExternalFenceFeatureFlags; + +// Flag bits for VkFenceImportFlagBits +typedef VkFlags VkFenceImportFlagBits; +static constexpr VkFenceImportFlagBits VK_FENCE_IMPORT_TEMPORARY_BIT {0x00000001U}; + +typedef VkFlags VkFenceImportFlags; + +// Flag bits for VkSemaphoreImportFlagBits +typedef VkFlags VkSemaphoreImportFlagBits; +static constexpr VkSemaphoreImportFlagBits VK_SEMAPHORE_IMPORT_TEMPORARY_BIT {0x00000001U}; + +typedef VkFlags VkSemaphoreImportFlags; + +// Flag bits for VkExternalSemaphoreHandleTypeFlagBits +typedef VkFlags VkExternalSemaphoreHandleTypeFlagBits; +static constexpr VkExternalSemaphoreHandleTypeFlagBits VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT {0x00000001U}; +static constexpr VkExternalSemaphoreHandleTypeFlagBits VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT {0x00000002U}; +static constexpr VkExternalSemaphoreHandleTypeFlagBits VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT {0x00000004U}; +static constexpr VkExternalSemaphoreHandleTypeFlagBits VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT {0x00000008U}; +static constexpr VkExternalSemaphoreHandleTypeFlagBits VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT {0x00000010U}; +static constexpr VkExternalSemaphoreHandleTypeFlagBits VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT {VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT}; + +typedef VkFlags VkExternalSemaphoreHandleTypeFlags; + +// Flag bits for VkExternalSemaphoreFeatureFlagBits +typedef VkFlags VkExternalSemaphoreFeatureFlagBits; +static constexpr VkExternalSemaphoreFeatureFlagBits VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT {0x00000001U}; +static constexpr VkExternalSemaphoreFeatureFlagBits VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT {0x00000002U}; + +typedef VkFlags VkExternalSemaphoreFeatureFlags; +typedef struct VkPhysicalDeviceSubgroupProperties { + VkStructureType sType; + void* pNext; + uint32_t subgroupSize; + VkShaderStageFlags supportedStages; + VkSubgroupFeatureFlags supportedOperations; + VkBool32 quadOperationsInAllStages; +} VkPhysicalDeviceSubgroupProperties; + +typedef struct VkBindBufferMemoryInfo { + VkStructureType sType; + void const* pNext; + VkBuffer buffer; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} VkBindBufferMemoryInfo; + +typedef struct VkBindImageMemoryInfo { + VkStructureType sType; + void const* pNext; + VkImage image; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} VkBindImageMemoryInfo; + +typedef struct VkPhysicalDevice16BitStorageFeatures { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; +} VkPhysicalDevice16BitStorageFeatures; + +typedef struct VkMemoryDedicatedRequirements { + VkStructureType sType; + void* pNext; + VkBool32 prefersDedicatedAllocation; + VkBool32 requiresDedicatedAllocation; +} VkMemoryDedicatedRequirements; + +typedef struct VkMemoryDedicatedAllocateInfo { + VkStructureType sType; + void const* pNext; + VkImage image; + VkBuffer buffer; +} VkMemoryDedicatedAllocateInfo; + +typedef struct VkMemoryAllocateFlagsInfo { + VkStructureType sType; + void const* pNext; + VkMemoryAllocateFlags flags; + uint32_t deviceMask; +} VkMemoryAllocateFlagsInfo; + +typedef struct VkDeviceGroupRenderPassBeginInfo { + VkStructureType sType; + void const* pNext; + uint32_t deviceMask; + uint32_t deviceRenderAreaCount; + VkRect2D const* pDeviceRenderAreas; +} VkDeviceGroupRenderPassBeginInfo; + +typedef struct VkDeviceGroupCommandBufferBeginInfo { + VkStructureType sType; + void const* pNext; + uint32_t deviceMask; +} VkDeviceGroupCommandBufferBeginInfo; + +typedef struct VkDeviceGroupSubmitInfo { + VkStructureType sType; + void const* pNext; + uint32_t waitSemaphoreCount; + uint32_t const* pWaitSemaphoreDeviceIndices; + uint32_t commandBufferCount; + uint32_t const* pCommandBufferDeviceMasks; + uint32_t signalSemaphoreCount; + uint32_t const* pSignalSemaphoreDeviceIndices; +} VkDeviceGroupSubmitInfo; + +typedef struct VkBindBufferMemoryDeviceGroupInfo { + VkStructureType sType; + void const* pNext; + uint32_t deviceIndexCount; + uint32_t const* pDeviceIndices; +} VkBindBufferMemoryDeviceGroupInfo; + +typedef struct VkBindImageMemoryDeviceGroupInfo { + VkStructureType sType; + void const* pNext; + uint32_t deviceIndexCount; + uint32_t const* pDeviceIndices; + uint32_t splitInstanceBindRegionCount; + VkRect2D const* pSplitInstanceBindRegions; +} VkBindImageMemoryDeviceGroupInfo; + +typedef struct VkPhysicalDeviceGroupProperties { + VkStructureType sType; + void* pNext; + uint32_t physicalDeviceCount; + VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; + VkBool32 subsetAllocation; +} VkPhysicalDeviceGroupProperties; + +typedef struct VkDeviceGroupDeviceCreateInfo { + VkStructureType sType; + void const* pNext; + uint32_t physicalDeviceCount; + VkPhysicalDevice const* pPhysicalDevices; +} VkDeviceGroupDeviceCreateInfo; + +typedef struct VkBufferMemoryRequirementsInfo2 { + VkStructureType sType; + void const* pNext; + VkBuffer buffer; +} VkBufferMemoryRequirementsInfo2; + +typedef struct VkImageMemoryRequirementsInfo2 { + VkStructureType sType; + void const* pNext; + VkImage image; +} VkImageMemoryRequirementsInfo2; + +typedef struct VkMemoryRequirements2 { + VkStructureType sType; + void* pNext; + VkMemoryRequirements memoryRequirements; +} VkMemoryRequirements2; + +typedef struct VkPhysicalDeviceFeatures2 { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceFeatures features; +} VkPhysicalDeviceFeatures2; + +typedef struct VkPhysicalDeviceProperties2 { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceProperties properties; +} VkPhysicalDeviceProperties2; + +typedef struct VkFormatProperties2 { + VkStructureType sType; + void* pNext; + VkFormatProperties formatProperties; +} VkFormatProperties2; + +typedef struct VkImageFormatProperties2 { + VkStructureType sType; + void* pNext; + VkImageFormatProperties imageFormatProperties; +} VkImageFormatProperties2; + +typedef struct VkPhysicalDeviceImageFormatInfo2 { + VkStructureType sType; + void const* pNext; + VkFormat format; + VkImageType type; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; +} VkPhysicalDeviceImageFormatInfo2; + +typedef struct VkQueueFamilyProperties2 { + VkStructureType sType; + void* pNext; + VkQueueFamilyProperties queueFamilyProperties; +} VkQueueFamilyProperties2; + +typedef struct VkPhysicalDeviceMemoryProperties2 { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceMemoryProperties memoryProperties; +} VkPhysicalDeviceMemoryProperties2; + +typedef struct VkPhysicalDevicePointClippingProperties { + VkStructureType sType; + void* pNext; + VkPointClippingBehavior pointClippingBehavior; +} VkPhysicalDevicePointClippingProperties; + +typedef struct VkInputAttachmentAspectReference { + uint32_t subpass; + uint32_t inputAttachmentIndex; + VkImageAspectFlags aspectMask; +} VkInputAttachmentAspectReference; + +typedef struct VkRenderPassInputAttachmentAspectCreateInfo { + VkStructureType sType; + void const* pNext; + uint32_t aspectReferenceCount; + VkInputAttachmentAspectReference const* pAspectReferences; +} VkRenderPassInputAttachmentAspectCreateInfo; + +typedef struct VkImageViewUsageCreateInfo { + VkStructureType sType; + void const* pNext; + VkImageUsageFlags usage; +} VkImageViewUsageCreateInfo; + +typedef struct VkPipelineTessellationDomainOriginStateCreateInfo { + VkStructureType sType; + void const* pNext; + VkTessellationDomainOrigin domainOrigin; +} VkPipelineTessellationDomainOriginStateCreateInfo; + +typedef struct VkRenderPassMultiviewCreateInfo { + VkStructureType sType; + void const* pNext; + uint32_t subpassCount; + uint32_t const* pViewMasks; + uint32_t dependencyCount; + int32_t const* pViewOffsets; + uint32_t correlationMaskCount; + uint32_t const* pCorrelationMasks; +} VkRenderPassMultiviewCreateInfo; + +typedef struct VkPhysicalDeviceMultiviewFeatures { + VkStructureType sType; + void* pNext; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; +} VkPhysicalDeviceMultiviewFeatures; + +typedef struct VkPhysicalDeviceMultiviewProperties { + VkStructureType sType; + void* pNext; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; +} VkPhysicalDeviceMultiviewProperties; + +typedef struct VkPhysicalDeviceVariablePointersFeatures { + VkStructureType sType; + void* pNext; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; +} VkPhysicalDeviceVariablePointersFeatures; + +typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures; + +typedef struct VkPhysicalDeviceProtectedMemoryFeatures { + VkStructureType sType; + void* pNext; + VkBool32 protectedMemory; +} VkPhysicalDeviceProtectedMemoryFeatures; + +typedef struct VkPhysicalDeviceProtectedMemoryProperties { + VkStructureType sType; + void* pNext; + VkBool32 protectedNoFault; +} VkPhysicalDeviceProtectedMemoryProperties; + +typedef struct VkDeviceQueueInfo2 { + VkStructureType sType; + void const* pNext; + VkDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueIndex; +} VkDeviceQueueInfo2; + +typedef struct VkProtectedSubmitInfo { + VkStructureType sType; + void const* pNext; + VkBool32 protectedSubmit; +} VkProtectedSubmitInfo; + +typedef struct VkSamplerYcbcrConversionCreateInfo { + VkStructureType sType; + void const* pNext; + VkFormat format; + VkSamplerYcbcrModelConversion ycbcrModel; + VkSamplerYcbcrRange ycbcrRange; + VkComponentMapping components; + VkChromaLocation xChromaOffset; + VkChromaLocation yChromaOffset; + VkFilter chromaFilter; + VkBool32 forceExplicitReconstruction; +} VkSamplerYcbcrConversionCreateInfo; + +typedef struct VkSamplerYcbcrConversionInfo { + VkStructureType sType; + void const* pNext; + VkSamplerYcbcrConversion conversion; +} VkSamplerYcbcrConversionInfo; + +typedef struct VkBindImagePlaneMemoryInfo { + VkStructureType sType; + void const* pNext; + VkImageAspectFlagBits planeAspect; +} VkBindImagePlaneMemoryInfo; + +typedef struct VkImagePlaneMemoryRequirementsInfo { + VkStructureType sType; + void const* pNext; + VkImageAspectFlagBits planeAspect; +} VkImagePlaneMemoryRequirementsInfo; + +typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures { + VkStructureType sType; + void* pNext; + VkBool32 samplerYcbcrConversion; +} VkPhysicalDeviceSamplerYcbcrConversionFeatures; + +typedef struct VkSamplerYcbcrConversionImageFormatProperties { + VkStructureType sType; + void* pNext; + uint32_t combinedImageSamplerDescriptorCount; +} VkSamplerYcbcrConversionImageFormatProperties; + +typedef struct VkExternalMemoryProperties { + VkExternalMemoryFeatureFlags externalMemoryFeatures; + VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes; + VkExternalMemoryHandleTypeFlags compatibleHandleTypes; +} VkExternalMemoryProperties; + +typedef struct VkPhysicalDeviceExternalImageFormatInfo { + VkStructureType sType; + void const* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalImageFormatInfo; + +typedef struct VkExternalImageFormatProperties { + VkStructureType sType; + void* pNext; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalImageFormatProperties; + +typedef struct VkPhysicalDeviceExternalBufferInfo { + VkStructureType sType; + void const* pNext; + VkBufferCreateFlags flags; + VkBufferUsageFlags usage; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalBufferInfo; + +typedef struct VkExternalBufferProperties { + VkStructureType sType; + void* pNext; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalBufferProperties; + +typedef struct VkPhysicalDeviceIDProperties { + VkStructureType sType; + void* pNext; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE]; + uint32_t deviceNodeMask; + VkBool32 deviceLUIDValid; +} VkPhysicalDeviceIDProperties; + +typedef struct VkExternalMemoryImageCreateInfo { + VkStructureType sType; + void const* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryImageCreateInfo; + +typedef struct VkExternalMemoryBufferCreateInfo { + VkStructureType sType; + void const* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryBufferCreateInfo; + +typedef struct VkExportMemoryAllocateInfo { + VkStructureType sType; + void const* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExportMemoryAllocateInfo; + +typedef struct VkPhysicalDeviceExternalFenceInfo { + VkStructureType sType; + void const* pNext; + VkExternalFenceHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalFenceInfo; + +typedef struct VkExternalFenceProperties { + VkStructureType sType; + void* pNext; + VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; + VkExternalFenceHandleTypeFlags compatibleHandleTypes; + VkExternalFenceFeatureFlags externalFenceFeatures; +} VkExternalFenceProperties; + +typedef struct VkExportFenceCreateInfo { + VkStructureType sType; + void const* pNext; + VkExternalFenceHandleTypeFlags handleTypes; +} VkExportFenceCreateInfo; + +typedef struct VkExportSemaphoreCreateInfo { + VkStructureType sType; + void const* pNext; + VkExternalSemaphoreHandleTypeFlags handleTypes; +} VkExportSemaphoreCreateInfo; + +typedef struct VkPhysicalDeviceExternalSemaphoreInfo { + VkStructureType sType; + void const* pNext; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalSemaphoreInfo; + +typedef struct VkExternalSemaphoreProperties { + VkStructureType sType; + void* pNext; + VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; + VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; + VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; +} VkExternalSemaphoreProperties; + +typedef struct VkPhysicalDeviceMaintenance3Properties { + VkStructureType sType; + void* pNext; + uint32_t maxPerSetDescriptors; + VkDeviceSize maxMemoryAllocationSize; +} VkPhysicalDeviceMaintenance3Properties; + +typedef struct VkDescriptorSetLayoutSupport { + VkStructureType sType; + void* pNext; + VkBool32 supported; +} VkDescriptorSetLayoutSupport; + +typedef struct VkPhysicalDeviceShaderDrawParametersFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderDrawParameters; +} VkPhysicalDeviceShaderDrawParametersFeatures; + +typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures; + +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion); +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, VkBindBufferMemoryInfo const * pBindInfos); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, VkBindImageMemoryInfo const * pBindInfos); +typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, VkImageMemoryRequirementsInfo2 const * pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, VkBufferMemoryRequirementsInfo2 const * pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceImageFormatInfo2 const * pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice device, VkDeviceQueueInfo2 const * pQueueInfo, VkQueue* pQueue); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversionCreateInfo const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); +typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, VkAllocationCallbacks const * pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalBufferInfo const * pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalFenceInfo const * pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalSemaphoreInfo const * pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, VkDescriptorSetLayoutCreateInfo const * pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion( + uint32_t* pApiVersion); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2( + VkDevice device, + uint32_t bindInfoCount, + VkBindBufferMemoryInfo const* pBindInfos); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2( + VkDevice device, + uint32_t bindInfoCount, + VkBindImageMemoryInfo const* pBindInfos); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures( + VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask( + VkCommandBuffer commandBuffer, + uint32_t deviceMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase( + VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups( + VkInstance instance, + uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2( + VkDevice device, + VkImageMemoryRequirementsInfo2 const* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2( + VkDevice device, + VkBufferMemoryRequirementsInfo2 const* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2* pFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceImageFormatInfo2 const* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2( + VkDevice device, + VkDeviceQueueInfo2 const* pQueueInfo, + VkQueue* pQueue); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion( + VkDevice device, + VkSamplerYcbcrConversionCreateInfo const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion); + +VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion( + VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + VkAllocationCallbacks const* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceExternalBufferInfo const* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceExternalFenceInfo const* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceExternalSemaphoreInfo const* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport( + VkDevice device, + VkDescriptorSetLayoutCreateInfo const* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport); +#endif + + +#define VK_VERSION_1_2 1 +// Vulkan 1.2 version number +#define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0)// Patch version should always be set to 0 + +static constexpr uint32_t VK_MAX_DRIVER_NAME_SIZE {static_cast(256U)}; +static constexpr uint32_t VK_MAX_DRIVER_INFO_SIZE {static_cast(256U)}; + +typedef enum VkDriverId { + VK_DRIVER_ID_AMD_PROPRIETARY = 1, + VK_DRIVER_ID_AMD_OPEN_SOURCE = 2, + VK_DRIVER_ID_MESA_RADV = 3, + VK_DRIVER_ID_NVIDIA_PROPRIETARY = 4, + VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5, + VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6, + VK_DRIVER_ID_IMAGINATION_PROPRIETARY = 7, + VK_DRIVER_ID_QUALCOMM_PROPRIETARY = 8, + VK_DRIVER_ID_ARM_PROPRIETARY = 9, + VK_DRIVER_ID_GOOGLE_SWIFTSHADER = 10, + VK_DRIVER_ID_GGP_PROPRIETARY = 11, + VK_DRIVER_ID_BROADCOM_PROPRIETARY = 12, + VK_DRIVER_ID_MESA_LLVMPIPE = 13, + VK_DRIVER_ID_MOLTENVK = 14, + VK_DRIVER_ID_COREAVI_PROPRIETARY = 15, + VK_DRIVER_ID_JUICE_PROPRIETARY = 16, + VK_DRIVER_ID_VERISILICON_PROPRIETARY = 17, + VK_DRIVER_ID_MESA_TURNIP = 18, + VK_DRIVER_ID_MESA_V3DV = 19, + VK_DRIVER_ID_MESA_PANVK = 20, + VK_DRIVER_ID_SAMSUNG_PROPRIETARY = 21, + VK_DRIVER_ID_MAX_ENUM = 0x7FFFFFFF +} VkDriverId; + +typedef enum VkShaderFloatControlsIndependence { + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 0x7FFFFFFF +} VkShaderFloatControlsIndependence; + +typedef enum VkSamplerReductionMode { + VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0, + VK_SAMPLER_REDUCTION_MODE_MIN = 1, + VK_SAMPLER_REDUCTION_MODE_MAX = 2, + VK_SAMPLER_REDUCTION_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerReductionMode; + +typedef enum VkSemaphoreType { + VK_SEMAPHORE_TYPE_BINARY = 0, + VK_SEMAPHORE_TYPE_TIMELINE = 1, + VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkSemaphoreType; + +// Flag bits for VkResolveModeFlagBits +typedef VkFlags VkResolveModeFlagBits; +static constexpr VkResolveModeFlagBits VK_RESOLVE_MODE_NONE {0U}; +static constexpr VkResolveModeFlagBits VK_RESOLVE_MODE_SAMPLE_ZERO_BIT {0x00000001U}; +static constexpr VkResolveModeFlagBits VK_RESOLVE_MODE_AVERAGE_BIT {0x00000002U}; +static constexpr VkResolveModeFlagBits VK_RESOLVE_MODE_MIN_BIT {0x00000004U}; +static constexpr VkResolveModeFlagBits VK_RESOLVE_MODE_MAX_BIT {0x00000008U}; + +typedef VkFlags VkResolveModeFlags; + +// Flag bits for VkDescriptorBindingFlagBits +typedef VkFlags VkDescriptorBindingFlagBits; +static constexpr VkDescriptorBindingFlagBits VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT {0x00000001U}; +static constexpr VkDescriptorBindingFlagBits VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT {0x00000002U}; +static constexpr VkDescriptorBindingFlagBits VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT {0x00000004U}; +static constexpr VkDescriptorBindingFlagBits VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT {0x00000008U}; + +typedef VkFlags VkDescriptorBindingFlags; + +// Flag bits for VkSemaphoreWaitFlagBits +typedef VkFlags VkSemaphoreWaitFlagBits; +static constexpr VkSemaphoreWaitFlagBits VK_SEMAPHORE_WAIT_ANY_BIT {0x00000001U}; + +typedef VkFlags VkSemaphoreWaitFlags; +typedef struct VkPhysicalDeviceVulkan11Features { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; + VkBool32 protectedMemory; + VkBool32 samplerYcbcrConversion; + VkBool32 shaderDrawParameters; +} VkPhysicalDeviceVulkan11Features; + +typedef struct VkPhysicalDeviceVulkan11Properties { + VkStructureType sType; + void* pNext; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE]; + uint32_t deviceNodeMask; + VkBool32 deviceLUIDValid; + uint32_t subgroupSize; + VkShaderStageFlags subgroupSupportedStages; + VkSubgroupFeatureFlags subgroupSupportedOperations; + VkBool32 subgroupQuadOperationsInAllStages; + VkPointClippingBehavior pointClippingBehavior; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; + VkBool32 protectedNoFault; + uint32_t maxPerSetDescriptors; + VkDeviceSize maxMemoryAllocationSize; +} VkPhysicalDeviceVulkan11Properties; + +typedef struct VkPhysicalDeviceVulkan12Features { + VkStructureType sType; + void* pNext; + VkBool32 samplerMirrorClampToEdge; + VkBool32 drawIndirectCount; + VkBool32 storageBuffer8BitAccess; + VkBool32 uniformAndStorageBuffer8BitAccess; + VkBool32 storagePushConstant8; + VkBool32 shaderBufferInt64Atomics; + VkBool32 shaderSharedInt64Atomics; + VkBool32 shaderFloat16; + VkBool32 shaderInt8; + VkBool32 descriptorIndexing; + VkBool32 shaderInputAttachmentArrayDynamicIndexing; + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; + VkBool32 shaderUniformBufferArrayNonUniformIndexing; + VkBool32 shaderSampledImageArrayNonUniformIndexing; + VkBool32 shaderStorageBufferArrayNonUniformIndexing; + VkBool32 shaderStorageImageArrayNonUniformIndexing; + VkBool32 shaderInputAttachmentArrayNonUniformIndexing; + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; + VkBool32 descriptorBindingUniformBufferUpdateAfterBind; + VkBool32 descriptorBindingSampledImageUpdateAfterBind; + VkBool32 descriptorBindingStorageImageUpdateAfterBind; + VkBool32 descriptorBindingStorageBufferUpdateAfterBind; + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingUpdateUnusedWhilePending; + VkBool32 descriptorBindingPartiallyBound; + VkBool32 descriptorBindingVariableDescriptorCount; + VkBool32 runtimeDescriptorArray; + VkBool32 samplerFilterMinmax; + VkBool32 scalarBlockLayout; + VkBool32 imagelessFramebuffer; + VkBool32 uniformBufferStandardLayout; + VkBool32 shaderSubgroupExtendedTypes; + VkBool32 separateDepthStencilLayouts; + VkBool32 hostQueryReset; + VkBool32 timelineSemaphore; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; + VkBool32 vulkanMemoryModel; + VkBool32 vulkanMemoryModelDeviceScope; + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; + VkBool32 shaderOutputViewportIndex; + VkBool32 shaderOutputLayer; + VkBool32 subgroupBroadcastDynamicId; +} VkPhysicalDeviceVulkan12Features; + +typedef struct VkConformanceVersion { + uint8_t major; + uint8_t minor; + uint8_t subminor; + uint8_t patch; +} VkConformanceVersion; + +typedef struct VkPhysicalDeviceVulkan12Properties { + VkStructureType sType; + void* pNext; + VkDriverId driverID; + char driverName[VK_MAX_DRIVER_NAME_SIZE]; + char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; + VkConformanceVersion conformanceVersion; + VkShaderFloatControlsIndependence denormBehaviorIndependence; + VkShaderFloatControlsIndependence roundingModeIndependence; + VkBool32 shaderSignedZeroInfNanPreserveFloat16; + VkBool32 shaderSignedZeroInfNanPreserveFloat32; + VkBool32 shaderSignedZeroInfNanPreserveFloat64; + VkBool32 shaderDenormPreserveFloat16; + VkBool32 shaderDenormPreserveFloat32; + VkBool32 shaderDenormPreserveFloat64; + VkBool32 shaderDenormFlushToZeroFloat16; + VkBool32 shaderDenormFlushToZeroFloat32; + VkBool32 shaderDenormFlushToZeroFloat64; + VkBool32 shaderRoundingModeRTEFloat16; + VkBool32 shaderRoundingModeRTEFloat32; + VkBool32 shaderRoundingModeRTEFloat64; + VkBool32 shaderRoundingModeRTZFloat16; + VkBool32 shaderRoundingModeRTZFloat32; + VkBool32 shaderRoundingModeRTZFloat64; + uint32_t maxUpdateAfterBindDescriptorsInAllPools; + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; + VkBool32 shaderSampledImageArrayNonUniformIndexingNative; + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; + VkBool32 shaderStorageImageArrayNonUniformIndexingNative; + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; + VkBool32 robustBufferAccessUpdateAfterBind; + VkBool32 quadDivergentImplicitLod; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint32_t maxPerStageUpdateAfterBindResources; + uint32_t maxDescriptorSetUpdateAfterBindSamplers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; + VkResolveModeFlags supportedDepthResolveModes; + VkResolveModeFlags supportedStencilResolveModes; + VkBool32 independentResolveNone; + VkBool32 independentResolve; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; + uint64_t maxTimelineSemaphoreValueDifference; + VkSampleCountFlags framebufferIntegerColorSampleCounts; +} VkPhysicalDeviceVulkan12Properties; + +typedef struct VkImageFormatListCreateInfo { + VkStructureType sType; + void const* pNext; + uint32_t viewFormatCount; + VkFormat const* pViewFormats; +} VkImageFormatListCreateInfo; + +typedef struct VkAttachmentDescription2 { + VkStructureType sType; + void const* pNext; + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription2; + +typedef struct VkAttachmentReference2 { + VkStructureType sType; + void const* pNext; + uint32_t attachment; + VkImageLayout layout; + VkImageAspectFlags aspectMask; +} VkAttachmentReference2; + +typedef struct VkSubpassDescription2 { + VkStructureType sType; + void const* pNext; + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t viewMask; + uint32_t inputAttachmentCount; + VkAttachmentReference2 const* pInputAttachments; + uint32_t colorAttachmentCount; + VkAttachmentReference2 const* pColorAttachments; + VkAttachmentReference2 const* pResolveAttachments; + VkAttachmentReference2 const* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + uint32_t const* pPreserveAttachments; +} VkSubpassDescription2; + +typedef struct VkSubpassDependency2 { + VkStructureType sType; + void const* pNext; + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; + int32_t viewOffset; +} VkSubpassDependency2; + +typedef struct VkRenderPassCreateInfo2 { + VkStructureType sType; + void const* pNext; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + VkAttachmentDescription2 const* pAttachments; + uint32_t subpassCount; + VkSubpassDescription2 const* pSubpasses; + uint32_t dependencyCount; + VkSubpassDependency2 const* pDependencies; + uint32_t correlatedViewMaskCount; + uint32_t const* pCorrelatedViewMasks; +} VkRenderPassCreateInfo2; + +typedef struct VkSubpassBeginInfo { + VkStructureType sType; + void const* pNext; + VkSubpassContents contents; +} VkSubpassBeginInfo; + +typedef struct VkSubpassEndInfo { + VkStructureType sType; + void const* pNext; +} VkSubpassEndInfo; + +typedef struct VkPhysicalDevice8BitStorageFeatures { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer8BitAccess; + VkBool32 uniformAndStorageBuffer8BitAccess; + VkBool32 storagePushConstant8; +} VkPhysicalDevice8BitStorageFeatures; + +typedef struct VkPhysicalDeviceDriverProperties { + VkStructureType sType; + void* pNext; + VkDriverId driverID; + char driverName[VK_MAX_DRIVER_NAME_SIZE]; + char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; + VkConformanceVersion conformanceVersion; +} VkPhysicalDeviceDriverProperties; + +typedef struct VkPhysicalDeviceShaderAtomicInt64Features { + VkStructureType sType; + void* pNext; + VkBool32 shaderBufferInt64Atomics; + VkBool32 shaderSharedInt64Atomics; +} VkPhysicalDeviceShaderAtomicInt64Features; + +typedef struct VkPhysicalDeviceShaderFloat16Int8Features { + VkStructureType sType; + void* pNext; + VkBool32 shaderFloat16; + VkBool32 shaderInt8; +} VkPhysicalDeviceShaderFloat16Int8Features; + +typedef struct VkPhysicalDeviceFloatControlsProperties { + VkStructureType sType; + void* pNext; + VkShaderFloatControlsIndependence denormBehaviorIndependence; + VkShaderFloatControlsIndependence roundingModeIndependence; + VkBool32 shaderSignedZeroInfNanPreserveFloat16; + VkBool32 shaderSignedZeroInfNanPreserveFloat32; + VkBool32 shaderSignedZeroInfNanPreserveFloat64; + VkBool32 shaderDenormPreserveFloat16; + VkBool32 shaderDenormPreserveFloat32; + VkBool32 shaderDenormPreserveFloat64; + VkBool32 shaderDenormFlushToZeroFloat16; + VkBool32 shaderDenormFlushToZeroFloat32; + VkBool32 shaderDenormFlushToZeroFloat64; + VkBool32 shaderRoundingModeRTEFloat16; + VkBool32 shaderRoundingModeRTEFloat32; + VkBool32 shaderRoundingModeRTEFloat64; + VkBool32 shaderRoundingModeRTZFloat16; + VkBool32 shaderRoundingModeRTZFloat32; + VkBool32 shaderRoundingModeRTZFloat64; +} VkPhysicalDeviceFloatControlsProperties; + +typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo { + VkStructureType sType; + void const* pNext; + uint32_t bindingCount; + VkDescriptorBindingFlags const* pBindingFlags; +} VkDescriptorSetLayoutBindingFlagsCreateInfo; + +typedef struct VkPhysicalDeviceDescriptorIndexingFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderInputAttachmentArrayDynamicIndexing; + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; + VkBool32 shaderUniformBufferArrayNonUniformIndexing; + VkBool32 shaderSampledImageArrayNonUniformIndexing; + VkBool32 shaderStorageBufferArrayNonUniformIndexing; + VkBool32 shaderStorageImageArrayNonUniformIndexing; + VkBool32 shaderInputAttachmentArrayNonUniformIndexing; + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; + VkBool32 descriptorBindingUniformBufferUpdateAfterBind; + VkBool32 descriptorBindingSampledImageUpdateAfterBind; + VkBool32 descriptorBindingStorageImageUpdateAfterBind; + VkBool32 descriptorBindingStorageBufferUpdateAfterBind; + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingUpdateUnusedWhilePending; + VkBool32 descriptorBindingPartiallyBound; + VkBool32 descriptorBindingVariableDescriptorCount; + VkBool32 runtimeDescriptorArray; +} VkPhysicalDeviceDescriptorIndexingFeatures; + +typedef struct VkPhysicalDeviceDescriptorIndexingProperties { + VkStructureType sType; + void* pNext; + uint32_t maxUpdateAfterBindDescriptorsInAllPools; + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; + VkBool32 shaderSampledImageArrayNonUniformIndexingNative; + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; + VkBool32 shaderStorageImageArrayNonUniformIndexingNative; + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; + VkBool32 robustBufferAccessUpdateAfterBind; + VkBool32 quadDivergentImplicitLod; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint32_t maxPerStageUpdateAfterBindResources; + uint32_t maxDescriptorSetUpdateAfterBindSamplers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; +} VkPhysicalDeviceDescriptorIndexingProperties; + +typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo { + VkStructureType sType; + void const* pNext; + uint32_t descriptorSetCount; + uint32_t const* pDescriptorCounts; +} VkDescriptorSetVariableDescriptorCountAllocateInfo; + +typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport { + VkStructureType sType; + void* pNext; + uint32_t maxVariableDescriptorCount; +} VkDescriptorSetVariableDescriptorCountLayoutSupport; + +typedef struct VkSubpassDescriptionDepthStencilResolve { + VkStructureType sType; + void const* pNext; + VkResolveModeFlagBits depthResolveMode; + VkResolveModeFlagBits stencilResolveMode; + VkAttachmentReference2 const* pDepthStencilResolveAttachment; +} VkSubpassDescriptionDepthStencilResolve; + +typedef struct VkPhysicalDeviceDepthStencilResolveProperties { + VkStructureType sType; + void* pNext; + VkResolveModeFlags supportedDepthResolveModes; + VkResolveModeFlags supportedStencilResolveModes; + VkBool32 independentResolveNone; + VkBool32 independentResolve; +} VkPhysicalDeviceDepthStencilResolveProperties; + +typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures { + VkStructureType sType; + void* pNext; + VkBool32 scalarBlockLayout; +} VkPhysicalDeviceScalarBlockLayoutFeatures; + +typedef struct VkImageStencilUsageCreateInfo { + VkStructureType sType; + void const* pNext; + VkImageUsageFlags stencilUsage; +} VkImageStencilUsageCreateInfo; + +typedef struct VkSamplerReductionModeCreateInfo { + VkStructureType sType; + void const* pNext; + VkSamplerReductionMode reductionMode; +} VkSamplerReductionModeCreateInfo; + +typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties { + VkStructureType sType; + void* pNext; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; +} VkPhysicalDeviceSamplerFilterMinmaxProperties; + +typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures { + VkStructureType sType; + void* pNext; + VkBool32 vulkanMemoryModel; + VkBool32 vulkanMemoryModelDeviceScope; + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; +} VkPhysicalDeviceVulkanMemoryModelFeatures; + +typedef struct VkPhysicalDeviceImagelessFramebufferFeatures { + VkStructureType sType; + void* pNext; + VkBool32 imagelessFramebuffer; +} VkPhysicalDeviceImagelessFramebufferFeatures; + +typedef struct VkFramebufferAttachmentImageInfo { + VkStructureType sType; + void const* pNext; + VkImageCreateFlags flags; + VkImageUsageFlags usage; + uint32_t width; + uint32_t height; + uint32_t layerCount; + uint32_t viewFormatCount; + VkFormat const* pViewFormats; +} VkFramebufferAttachmentImageInfo; + +typedef struct VkFramebufferAttachmentsCreateInfo { + VkStructureType sType; + void const* pNext; + uint32_t attachmentImageInfoCount; + VkFramebufferAttachmentImageInfo const* pAttachmentImageInfos; +} VkFramebufferAttachmentsCreateInfo; + +typedef struct VkRenderPassAttachmentBeginInfo { + VkStructureType sType; + void const* pNext; + uint32_t attachmentCount; + VkImageView const* pAttachments; +} VkRenderPassAttachmentBeginInfo; + +typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures { + VkStructureType sType; + void* pNext; + VkBool32 uniformBufferStandardLayout; +} VkPhysicalDeviceUniformBufferStandardLayoutFeatures; + +typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderSubgroupExtendedTypes; +} VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures; + +typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures { + VkStructureType sType; + void* pNext; + VkBool32 separateDepthStencilLayouts; +} VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures; + +typedef struct VkAttachmentReferenceStencilLayout { + VkStructureType sType; + void* pNext; + VkImageLayout stencilLayout; +} VkAttachmentReferenceStencilLayout; + +typedef struct VkAttachmentDescriptionStencilLayout { + VkStructureType sType; + void* pNext; + VkImageLayout stencilInitialLayout; + VkImageLayout stencilFinalLayout; +} VkAttachmentDescriptionStencilLayout; + +typedef struct VkPhysicalDeviceHostQueryResetFeatures { + VkStructureType sType; + void* pNext; + VkBool32 hostQueryReset; +} VkPhysicalDeviceHostQueryResetFeatures; + +typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures { + VkStructureType sType; + void* pNext; + VkBool32 timelineSemaphore; +} VkPhysicalDeviceTimelineSemaphoreFeatures; + +typedef struct VkPhysicalDeviceTimelineSemaphoreProperties { + VkStructureType sType; + void* pNext; + uint64_t maxTimelineSemaphoreValueDifference; +} VkPhysicalDeviceTimelineSemaphoreProperties; + +typedef struct VkSemaphoreTypeCreateInfo { + VkStructureType sType; + void const* pNext; + VkSemaphoreType semaphoreType; + uint64_t initialValue; +} VkSemaphoreTypeCreateInfo; + +typedef struct VkTimelineSemaphoreSubmitInfo { + VkStructureType sType; + void const* pNext; + uint32_t waitSemaphoreValueCount; + uint64_t const* pWaitSemaphoreValues; + uint32_t signalSemaphoreValueCount; + uint64_t const* pSignalSemaphoreValues; +} VkTimelineSemaphoreSubmitInfo; + +typedef struct VkSemaphoreWaitInfo { + VkStructureType sType; + void const* pNext; + VkSemaphoreWaitFlags flags; + uint32_t semaphoreCount; + VkSemaphore const* pSemaphores; + uint64_t const* pValues; +} VkSemaphoreWaitInfo; + +typedef struct VkSemaphoreSignalInfo { + VkStructureType sType; + void const* pNext; + VkSemaphore semaphore; + uint64_t value; +} VkSemaphoreSignalInfo; + +typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures { + VkStructureType sType; + void* pNext; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; +} VkPhysicalDeviceBufferDeviceAddressFeatures; + +typedef struct VkBufferDeviceAddressInfo { + VkStructureType sType; + void const* pNext; + VkBuffer buffer; +} VkBufferDeviceAddressInfo; + +typedef struct VkBufferOpaqueCaptureAddressCreateInfo { + VkStructureType sType; + void const* pNext; + uint64_t opaqueCaptureAddress; +} VkBufferOpaqueCaptureAddressCreateInfo; + +typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo { + VkStructureType sType; + void const* pNext; + uint64_t opaqueCaptureAddress; +} VkMemoryOpaqueCaptureAddressAllocateInfo; + +typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo { + VkStructureType sType; + void const* pNext; + VkDeviceMemory memory; +} VkDeviceMemoryOpaqueCaptureAddressInfo; + +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2)(VkDevice device, VkRenderPassCreateInfo2 const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkRenderPass* pRenderPass); +typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2)(VkCommandBuffer commandBuffer, VkRenderPassBeginInfo const * pRenderPassBegin, VkSubpassBeginInfo const * pSubpassBeginInfo); +typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2)(VkCommandBuffer commandBuffer, VkSubpassBeginInfo const * pSubpassBeginInfo, VkSubpassEndInfo const * pSubpassEndInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2)(VkCommandBuffer commandBuffer, VkSubpassEndInfo const * pSubpassEndInfo); +typedef void (VKAPI_PTR *PFN_vkResetQueryPool)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValue)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue); +typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphores)(VkDevice device, VkSemaphoreWaitInfo const * pWaitInfo, uint64_t timeout); +typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphore)(VkDevice device, VkSemaphoreSignalInfo const * pSignalInfo); +typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddress)(VkDevice device, VkBufferDeviceAddressInfo const * pInfo); +typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice device, VkBufferDeviceAddressInfo const * pInfo); +typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddress)(VkDevice device, VkDeviceMemoryOpaqueCaptureAddressInfo const * pInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCount( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCount( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2( + VkDevice device, + VkRenderPassCreateInfo2 const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkRenderPass* pRenderPass); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2( + VkCommandBuffer commandBuffer, + VkRenderPassBeginInfo const* pRenderPassBegin, + VkSubpassBeginInfo const* pSubpassBeginInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2( + VkCommandBuffer commandBuffer, + VkSubpassBeginInfo const* pSubpassBeginInfo, + VkSubpassEndInfo const* pSubpassEndInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2( + VkCommandBuffer commandBuffer, + VkSubpassEndInfo const* pSubpassEndInfo); + +VKAPI_ATTR void VKAPI_CALL vkResetQueryPool( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValue( + VkDevice device, + VkSemaphore semaphore, + uint64_t* pValue); + +VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphores( + VkDevice device, + VkSemaphoreWaitInfo const* pWaitInfo, + uint64_t timeout); + +VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphore( + VkDevice device, + VkSemaphoreSignalInfo const* pSignalInfo); + +VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddress( + VkDevice device, + VkBufferDeviceAddressInfo const* pInfo); + +VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress( + VkDevice device, + VkBufferDeviceAddressInfo const* pInfo); + +VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddress( + VkDevice device, + VkDeviceMemoryOpaqueCaptureAddressInfo const* pInfo); +#endif + + +#define VKSC_VERSION_1_0 1 +// Vulkan SC 1.0 version number +#define VKSC_API_VERSION_1_0 VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, 0)// Patch version should always be set to 0 + + +typedef enum VkFaultLevel { + VK_FAULT_LEVEL_UNASSIGNED = 0, + VK_FAULT_LEVEL_CRITICAL = 1, + VK_FAULT_LEVEL_RECOVERABLE = 2, + VK_FAULT_LEVEL_WARNING = 3, + VK_FAULT_LEVEL_MAX_ENUM = 0x7FFFFFFF +} VkFaultLevel; + +typedef enum VkFaultType { + VK_FAULT_TYPE_INVALID = 0, + VK_FAULT_TYPE_UNASSIGNED = 1, + VK_FAULT_TYPE_IMPLEMENTATION = 2, + VK_FAULT_TYPE_SYSTEM = 3, + VK_FAULT_TYPE_PHYSICAL_DEVICE = 4, + VK_FAULT_TYPE_COMMAND_BUFFER_FULL = 5, + VK_FAULT_TYPE_INVALID_API_USAGE = 6, + VK_FAULT_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkFaultType; + +typedef enum VkFaultQueryBehavior { + VK_FAULT_QUERY_BEHAVIOR_GET_AND_CLEAR_ALL_FAULTS = 0, + VK_FAULT_QUERY_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF +} VkFaultQueryBehavior; + +typedef enum VkPipelineMatchControl { + VK_PIPELINE_MATCH_CONTROL_APPLICATION_UUID_EXACT_MATCH = 0, + VK_PIPELINE_MATCH_CONTROL_MAX_ENUM = 0x7FFFFFFF +} VkPipelineMatchControl; + +typedef enum VkPipelineCacheValidationVersion { + VK_PIPELINE_CACHE_VALIDATION_VERSION_SAFETY_CRITICAL_ONE = 1, + VK_PIPELINE_CACHE_VALIDATION_VERSION_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCacheValidationVersion; +typedef struct VkPhysicalDeviceVulkanSC10Features { + VkStructureType sType; + void* pNext; + VkBool32 shaderAtomicInstructions; +} VkPhysicalDeviceVulkanSC10Features; + +typedef struct VkPhysicalDeviceVulkanSC10Properties { + VkStructureType sType; + void* pNext; + VkBool32 deviceNoDynamicHostAllocations; + VkBool32 deviceDestroyFreesMemory; + VkBool32 commandPoolMultipleCommandBuffersRecording; + VkBool32 commandPoolResetCommandBuffer; + VkBool32 commandBufferSimultaneousUse; + VkBool32 secondaryCommandBufferNullOrImagelessFramebuffer; + VkBool32 recycleDescriptorSetMemory; + VkBool32 recyclePipelineMemory; + uint32_t maxRenderPassSubpasses; + uint32_t maxRenderPassDependencies; + uint32_t maxSubpassInputAttachments; + uint32_t maxSubpassPreserveAttachments; + uint32_t maxFramebufferAttachments; + uint32_t maxDescriptorSetLayoutBindings; + uint32_t maxQueryFaultCount; + uint32_t maxCallbackFaultCount; + uint32_t maxCommandPoolCommandBuffers; + VkDeviceSize maxCommandBufferSize; +} VkPhysicalDeviceVulkanSC10Properties; + +typedef struct VkPipelinePoolSize { + VkStructureType sType; + void const* pNext; + VkDeviceSize poolEntrySize; + uint32_t poolEntryCount; +} VkPipelinePoolSize; + +typedef struct VkDeviceObjectReservationCreateInfo { + VkStructureType sType; + void const* pNext; + uint32_t pipelineCacheCreateInfoCount; + VkPipelineCacheCreateInfo const* pPipelineCacheCreateInfos; + uint32_t pipelinePoolSizeCount; + VkPipelinePoolSize const* pPipelinePoolSizes; + uint32_t semaphoreRequestCount; + uint32_t commandBufferRequestCount; + uint32_t fenceRequestCount; + uint32_t deviceMemoryRequestCount; + uint32_t bufferRequestCount; + uint32_t imageRequestCount; + uint32_t eventRequestCount; + uint32_t queryPoolRequestCount; + uint32_t bufferViewRequestCount; + uint32_t imageViewRequestCount; + uint32_t layeredImageViewRequestCount; + uint32_t pipelineCacheRequestCount; + uint32_t pipelineLayoutRequestCount; + uint32_t renderPassRequestCount; + uint32_t graphicsPipelineRequestCount; + uint32_t computePipelineRequestCount; + uint32_t descriptorSetLayoutRequestCount; + uint32_t samplerRequestCount; + uint32_t descriptorPoolRequestCount; + uint32_t descriptorSetRequestCount; + uint32_t framebufferRequestCount; + uint32_t commandPoolRequestCount; + uint32_t samplerYcbcrConversionRequestCount; + uint32_t surfaceRequestCount; + uint32_t swapchainRequestCount; + uint32_t displayModeRequestCount; + uint32_t subpassDescriptionRequestCount; + uint32_t attachmentDescriptionRequestCount; + uint32_t descriptorSetLayoutBindingRequestCount; + uint32_t descriptorSetLayoutBindingLimit; + uint32_t maxImageViewMipLevels; + uint32_t maxImageViewArrayLayers; + uint32_t maxLayeredImageViewMipLevels; + uint32_t maxOcclusionQueriesPerPool; + uint32_t maxPipelineStatisticsQueriesPerPool; + uint32_t maxTimestampQueriesPerPool; + uint32_t maxImmutableSamplersPerDescriptorSetLayout; +} VkDeviceObjectReservationCreateInfo; + +typedef struct VkCommandPoolMemoryReservationCreateInfo { + VkStructureType sType; + void const* pNext; + VkDeviceSize commandPoolReservedSize; + uint32_t commandPoolMaxCommandBuffers; +} VkCommandPoolMemoryReservationCreateInfo; + +typedef struct VkCommandPoolMemoryConsumption { + VkStructureType sType; + void* pNext; + VkDeviceSize commandPoolAllocated; + VkDeviceSize commandPoolReservedSize; + VkDeviceSize commandBufferAllocated; +} VkCommandPoolMemoryConsumption; + +typedef struct VkFaultData { + VkStructureType sType; + void* pNext; + VkFaultLevel faultLevel; + VkFaultType faultType; +} VkFaultData; + +typedef void (VKAPI_PTR *PFN_vkFaultCallbackFunction)( + VkBool32 unrecordedFaults, + uint32_t faultCount, + const VkFaultData* pFaults); + +typedef struct VkFaultCallbackInfo { + VkStructureType sType; + void* pNext; + uint32_t faultCount; + VkFaultData* pFaults; + PFN_vkFaultCallbackFunction pfnFaultCallback; +} VkFaultCallbackInfo; + +typedef struct VkPipelineOfflineCreateInfo { + VkStructureType sType; + void const* pNext; + uint8_t pipelineIdentifier[VK_UUID_SIZE]; + VkPipelineMatchControl matchControl; + VkDeviceSize poolEntrySize; +} VkPipelineOfflineCreateInfo; + +typedef struct VkPipelineCacheStageValidationIndexEntry { + uint64_t codeSize; + uint64_t codeOffset; +} VkPipelineCacheStageValidationIndexEntry; + +typedef struct VkPipelineCacheSafetyCriticalIndexEntry { + uint8_t pipelineIdentifier[VK_UUID_SIZE]; + uint64_t pipelineMemorySize; + uint64_t jsonSize; + uint64_t jsonOffset; + uint32_t stageIndexCount; + uint32_t stageIndexStride; + uint64_t stageIndexOffset; +} VkPipelineCacheSafetyCriticalIndexEntry; + +typedef struct VkPipelineCacheHeaderVersionSafetyCriticalOne { + VkPipelineCacheHeaderVersionOne headerVersionOne; + VkPipelineCacheValidationVersion validationVersion; + uint32_t implementationData; + uint32_t pipelineIndexCount; + uint32_t pipelineIndexStride; + uint64_t pipelineIndexOffset; +} VkPipelineCacheHeaderVersionSafetyCriticalOne; + +typedef void (VKAPI_PTR *PFN_vkGetCommandPoolMemoryConsumption)(VkDevice device, VkCommandPool commandPool, VkCommandBuffer commandBuffer, VkCommandPoolMemoryConsumption* pConsumption); +typedef VkResult (VKAPI_PTR *PFN_vkGetFaultData)(VkDevice device, VkFaultQueryBehavior faultQueryBehavior, VkBool32* pUnrecordedFaults, uint32_t* pFaultCount, VkFaultData* pFaults); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetCommandPoolMemoryConsumption( + VkDevice device, + VkCommandPool commandPool, + VkCommandBuffer commandBuffer, + VkCommandPoolMemoryConsumption* pConsumption); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFaultData( + VkDevice device, + VkFaultQueryBehavior faultQueryBehavior, + VkBool32* pUnrecordedFaults, + uint32_t* pFaultCount, + VkFaultData* pFaults); +#endif + + +#define VK_KHR_surface 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) +#define VK_KHR_SURFACE_SPEC_VERSION 25 +#define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" + +typedef enum VkPresentModeKHR { + VK_PRESENT_MODE_IMMEDIATE_KHR = 0, + VK_PRESENT_MODE_MAILBOX_KHR = 1, + VK_PRESENT_MODE_FIFO_KHR = 2, + VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, + VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000, + VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001, + VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPresentModeKHR; + +typedef enum VkColorSpaceKHR { + VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, + VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001, + VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002, + VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104003, + VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004, + VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005, + VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006, + VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007, + VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008, + VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009, + VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010, + VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011, + VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012, + VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013, + VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014, + VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkColorSpaceKHR; + +// Flag bits for VkSurfaceTransformFlagBitsKHR +typedef VkFlags VkSurfaceTransformFlagBitsKHR; +static constexpr VkSurfaceTransformFlagBitsKHR VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR {0x00000001U}; +static constexpr VkSurfaceTransformFlagBitsKHR VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR {0x00000002U}; +static constexpr VkSurfaceTransformFlagBitsKHR VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR {0x00000004U}; +static constexpr VkSurfaceTransformFlagBitsKHR VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR {0x00000008U}; +static constexpr VkSurfaceTransformFlagBitsKHR VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR {0x00000010U}; +static constexpr VkSurfaceTransformFlagBitsKHR VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR {0x00000020U}; +static constexpr VkSurfaceTransformFlagBitsKHR VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR {0x00000040U}; +static constexpr VkSurfaceTransformFlagBitsKHR VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR {0x00000080U}; +static constexpr VkSurfaceTransformFlagBitsKHR VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR {0x00000100U}; + + +// Flag bits for VkCompositeAlphaFlagBitsKHR +typedef VkFlags VkCompositeAlphaFlagBitsKHR; +static constexpr VkCompositeAlphaFlagBitsKHR VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR {0x00000001U}; +static constexpr VkCompositeAlphaFlagBitsKHR VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR {0x00000002U}; +static constexpr VkCompositeAlphaFlagBitsKHR VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR {0x00000004U}; +static constexpr VkCompositeAlphaFlagBitsKHR VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR {0x00000008U}; + +typedef VkFlags VkCompositeAlphaFlagsKHR; +typedef VkFlags VkSurfaceTransformFlagsKHR; +typedef struct VkSurfaceCapabilitiesKHR { + uint32_t minImageCount; + uint32_t maxImageCount; + VkExtent2D currentExtent; + VkExtent2D minImageExtent; + VkExtent2D maxImageExtent; + uint32_t maxImageArrayLayers; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkSurfaceTransformFlagBitsKHR currentTransform; + VkCompositeAlphaFlagsKHR supportedCompositeAlpha; + VkImageUsageFlags supportedUsageFlags; +} VkSurfaceCapabilitiesKHR; + +typedef struct VkSurfaceFormatKHR { + VkFormat format; + VkColorSpaceKHR colorSpace; +} VkSurfaceFormatKHR; + +typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, VkAllocationCallbacks const * pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( + VkInstance instance, + VkSurfaceKHR surface, + VkAllocationCallbacks const* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + VkSurfaceKHR surface, + VkBool32* pSupported); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormatKHR* pSurfaceFormats); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes); +#endif + + +#define VK_KHR_swapchain 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) +#define VK_KHR_SWAPCHAIN_SPEC_VERSION 70 +#define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" + +// Flag bits for VkSwapchainCreateFlagBitsKHR +typedef VkFlags VkSwapchainCreateFlagBitsKHR; +static constexpr VkSwapchainCreateFlagBitsKHR VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR {0x00000001U}; +static constexpr VkSwapchainCreateFlagBitsKHR VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR {0x00000002U}; +static constexpr VkSwapchainCreateFlagBitsKHR VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR {0x00000004U}; + +typedef VkFlags VkSwapchainCreateFlagsKHR; + +// Flag bits for VkDeviceGroupPresentModeFlagBitsKHR +typedef VkFlags VkDeviceGroupPresentModeFlagBitsKHR; +static constexpr VkDeviceGroupPresentModeFlagBitsKHR VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR {0x00000001U}; +static constexpr VkDeviceGroupPresentModeFlagBitsKHR VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR {0x00000002U}; +static constexpr VkDeviceGroupPresentModeFlagBitsKHR VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR {0x00000004U}; +static constexpr VkDeviceGroupPresentModeFlagBitsKHR VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR {0x00000008U}; + +typedef VkFlags VkDeviceGroupPresentModeFlagsKHR; +typedef struct VkSwapchainCreateInfoKHR { + VkStructureType sType; + void const* pNext; + VkSwapchainCreateFlagsKHR flags; + VkSurfaceKHR surface; + uint32_t minImageCount; + VkFormat imageFormat; + VkColorSpaceKHR imageColorSpace; + VkExtent2D imageExtent; + uint32_t imageArrayLayers; + VkImageUsageFlags imageUsage; + VkSharingMode imageSharingMode; + uint32_t queueFamilyIndexCount; + uint32_t const* pQueueFamilyIndices; + VkSurfaceTransformFlagBitsKHR preTransform; + VkCompositeAlphaFlagBitsKHR compositeAlpha; + VkPresentModeKHR presentMode; + VkBool32 clipped; + VkSwapchainKHR oldSwapchain; +} VkSwapchainCreateInfoKHR; + +typedef struct VkPresentInfoKHR { + VkStructureType sType; + void const* pNext; + uint32_t waitSemaphoreCount; + VkSemaphore const* pWaitSemaphores; + uint32_t swapchainCount; + VkSwapchainKHR const* pSwapchains; + uint32_t const* pImageIndices; + VkResult* pResults; +} VkPresentInfoKHR; + +typedef struct VkImageSwapchainCreateInfoKHR { + VkStructureType sType; + void const* pNext; + VkSwapchainKHR swapchain; +} VkImageSwapchainCreateInfoKHR; + +typedef struct VkBindImageMemorySwapchainInfoKHR { + VkStructureType sType; + void const* pNext; + VkSwapchainKHR swapchain; + uint32_t imageIndex; +} VkBindImageMemorySwapchainInfoKHR; + +typedef struct VkAcquireNextImageInfoKHR { + VkStructureType sType; + void const* pNext; + VkSwapchainKHR swapchain; + uint64_t timeout; + VkSemaphore semaphore; + VkFence fence; + uint32_t deviceMask; +} VkAcquireNextImageInfoKHR; + +typedef struct VkDeviceGroupPresentCapabilitiesKHR { + VkStructureType sType; + void* pNext; + uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; + VkDeviceGroupPresentModeFlagsKHR modes; +} VkDeviceGroupPresentCapabilitiesKHR; + +typedef struct VkDeviceGroupPresentInfoKHR { + VkStructureType sType; + void const* pNext; + uint32_t swapchainCount; + uint32_t const* pDeviceMasks; + VkDeviceGroupPresentModeFlagBitsKHR mode; +} VkDeviceGroupPresentInfoKHR; + +typedef struct VkDeviceGroupSwapchainCreateInfoKHR { + VkStructureType sType; + void const* pNext; + VkDeviceGroupPresentModeFlagsKHR modes; +} VkDeviceGroupSwapchainCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, VkSwapchainCreateInfoKHR const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkSwapchainKHR* pSwapchain); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); +typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, VkPresentInfoKHR const * pPresentInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice device, VkAcquireNextImageInfoKHR const * pAcquireInfo, uint32_t* pImageIndex); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( + VkDevice device, + VkSwapchainCreateInfoKHR const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkSwapchainKHR* pSwapchain); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pSwapchainImageCount, + VkImage* pSwapchainImages); + +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint64_t timeout, + VkSemaphore semaphore, + VkFence fence, + uint32_t* pImageIndex); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( + VkQueue queue, + VkPresentInfoKHR const* pPresentInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR( + VkDevice device, + VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR( + VkDevice device, + VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHR* pModes); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pRectCount, + VkRect2D* pRects); + +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR( + VkDevice device, + VkAcquireNextImageInfoKHR const* pAcquireInfo, + uint32_t* pImageIndex); +#endif + + +#define VK_KHR_display 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) +#define VK_KHR_DISPLAY_SPEC_VERSION 23 +#define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display" +typedef VkFlags VkDisplayModeCreateFlagsKHR; + +// Flag bits for VkDisplayPlaneAlphaFlagBitsKHR +typedef VkFlags VkDisplayPlaneAlphaFlagBitsKHR; +static constexpr VkDisplayPlaneAlphaFlagBitsKHR VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR {0x00000001U}; +static constexpr VkDisplayPlaneAlphaFlagBitsKHR VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR {0x00000002U}; +static constexpr VkDisplayPlaneAlphaFlagBitsKHR VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR {0x00000004U}; +static constexpr VkDisplayPlaneAlphaFlagBitsKHR VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR {0x00000008U}; + +typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; +typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; +typedef struct VkDisplayModeParametersKHR { + VkExtent2D visibleRegion; + uint32_t refreshRate; +} VkDisplayModeParametersKHR; + +typedef struct VkDisplayModeCreateInfoKHR { + VkStructureType sType; + void const* pNext; + VkDisplayModeCreateFlagsKHR flags; + VkDisplayModeParametersKHR parameters; +} VkDisplayModeCreateInfoKHR; + +typedef struct VkDisplayModePropertiesKHR { + VkDisplayModeKHR displayMode; + VkDisplayModeParametersKHR parameters; +} VkDisplayModePropertiesKHR; + +typedef struct VkDisplayPlaneCapabilitiesKHR { + VkDisplayPlaneAlphaFlagsKHR supportedAlpha; + VkOffset2D minSrcPosition; + VkOffset2D maxSrcPosition; + VkExtent2D minSrcExtent; + VkExtent2D maxSrcExtent; + VkOffset2D minDstPosition; + VkOffset2D maxDstPosition; + VkExtent2D minDstExtent; + VkExtent2D maxDstExtent; +} VkDisplayPlaneCapabilitiesKHR; + +typedef struct VkDisplayPlanePropertiesKHR { + VkDisplayKHR currentDisplay; + uint32_t currentStackIndex; +} VkDisplayPlanePropertiesKHR; + +typedef struct VkDisplayPropertiesKHR { + VkDisplayKHR display; + char const* displayName; + VkExtent2D physicalDimensions; + VkExtent2D physicalResolution; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkBool32 planeReorderPossible; + VkBool32 persistentContent; +} VkDisplayPropertiesKHR; + +typedef struct VkDisplaySurfaceCreateInfoKHR { + VkStructureType sType; + void const* pNext; + VkDisplaySurfaceCreateFlagsKHR flags; + VkDisplayModeKHR displayMode; + uint32_t planeIndex; + uint32_t planeStackIndex; + VkSurfaceTransformFlagBitsKHR transform; + float globalAlpha; + VkDisplayPlaneAlphaFlagBitsKHR alphaMode; + VkExtent2D imageExtent; +} VkDisplaySurfaceCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, VkDisplayModeCreateInfoKHR const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkDisplayModeKHR* pMode); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, VkDisplaySurfaceCreateInfoKHR const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlanePropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR( + VkPhysicalDevice physicalDevice, + uint32_t planeIndex, + uint32_t* pDisplayCount, + VkDisplayKHR* pDisplays); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModePropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + VkDisplayModeCreateInfoKHR const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkDisplayModeKHR* pMode); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayModeKHR mode, + uint32_t planeIndex, + VkDisplayPlaneCapabilitiesKHR* pCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR( + VkInstance instance, + VkDisplaySurfaceCreateInfoKHR const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkSurfaceKHR* pSurface); +#endif + + +#define VK_KHR_display_swapchain 1 +#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 10 +#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain" +typedef struct VkDisplayPresentInfoKHR { + VkStructureType sType; + void const* pNext; + VkRect2D srcRect; + VkRect2D dstRect; + VkBool32 persistent; +} VkDisplayPresentInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, VkSwapchainCreateInfoKHR const * pCreateInfos, VkAllocationCallbacks const * pAllocator, VkSwapchainKHR* pSwapchains); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR( + VkDevice device, + uint32_t swapchainCount, + VkSwapchainCreateInfoKHR const* pCreateInfos, + VkAllocationCallbacks const* pAllocator, + VkSwapchainKHR* pSwapchains); +#endif + + +#define VK_KHR_external_memory_fd 1 +#define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd" +typedef struct VkImportMemoryFdInfoKHR { + VkStructureType sType; + void const* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + int fd; +} VkImportMemoryFdInfoKHR; + +typedef struct VkMemoryFdPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryFdPropertiesKHR; + +typedef struct VkMemoryGetFdInfoKHR { + VkStructureType sType; + void const* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkMemoryGetFdInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, VkMemoryGetFdInfoKHR const * pGetFdInfo, int* pFd); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR( + VkDevice device, + VkMemoryGetFdInfoKHR const* pGetFdInfo, + int* pFd); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + int fd, + VkMemoryFdPropertiesKHR* pMemoryFdProperties); +#endif + + +#define VK_KHR_external_semaphore_fd 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd" +typedef struct VkImportSemaphoreFdInfoKHR { + VkStructureType sType; + void const* pNext; + VkSemaphore semaphore; + VkSemaphoreImportFlags flags; + VkExternalSemaphoreHandleTypeFlagBits handleType; + int fd; +} VkImportSemaphoreFdInfoKHR; + +typedef struct VkSemaphoreGetFdInfoKHR { + VkStructureType sType; + void const* pNext; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkSemaphoreGetFdInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, VkImportSemaphoreFdInfoKHR const * pImportSemaphoreFdInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, VkSemaphoreGetFdInfoKHR const * pGetFdInfo, int* pFd); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR( + VkDevice device, + VkImportSemaphoreFdInfoKHR const* pImportSemaphoreFdInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR( + VkDevice device, + VkSemaphoreGetFdInfoKHR const* pGetFdInfo, + int* pFd); +#endif + + +#define VK_KHR_incremental_present 1 +#define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 2 +#define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present" +typedef struct VkRectLayerKHR { + VkOffset2D offset; + VkExtent2D extent; + uint32_t layer; +} VkRectLayerKHR; + +typedef struct VkPresentRegionKHR { + uint32_t rectangleCount; + VkRectLayerKHR const* pRectangles; +} VkPresentRegionKHR; + +typedef struct VkPresentRegionsKHR { + VkStructureType sType; + void const* pNext; + uint32_t swapchainCount; + VkPresentRegionKHR const* pRegions; +} VkPresentRegionsKHR; + + + +#define VK_KHR_shared_presentable_image 1 +#define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1 +#define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image" +typedef struct VkSharedPresentSurfaceCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkImageUsageFlags sharedPresentSupportedUsageFlags; +} VkSharedPresentSurfaceCapabilitiesKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR( + VkDevice device, + VkSwapchainKHR swapchain); +#endif + + +#define VK_KHR_external_fence_fd 1 +#define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd" +typedef struct VkImportFenceFdInfoKHR { + VkStructureType sType; + void const* pNext; + VkFence fence; + VkFenceImportFlags flags; + VkExternalFenceHandleTypeFlagBits handleType; + int fd; +} VkImportFenceFdInfoKHR; + +typedef struct VkFenceGetFdInfoKHR { + VkStructureType sType; + void const* pNext; + VkFence fence; + VkExternalFenceHandleTypeFlagBits handleType; +} VkFenceGetFdInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, VkImportFenceFdInfoKHR const * pImportFenceFdInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, VkFenceGetFdInfoKHR const * pGetFdInfo, int* pFd); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR( + VkDevice device, + VkImportFenceFdInfoKHR const* pImportFenceFdInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR( + VkDevice device, + VkFenceGetFdInfoKHR const* pGetFdInfo, + int* pFd); +#endif + + +#define VK_KHR_performance_query 1 +#define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1 +#define VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME "VK_KHR_performance_query" + +typedef enum VkPerformanceCounterUnitKHR { + VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0, + VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1, + VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2, + VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3, + VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4, + VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5, + VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6, + VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7, + VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8, + VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9, + VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10, + VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterUnitKHR; + +typedef enum VkPerformanceCounterScopeKHR { + VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0, + VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1, + VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2, + VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, + VK_QUERY_SCOPE_RENDER_PASS_KHR = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, + VK_QUERY_SCOPE_COMMAND_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR, + VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterScopeKHR; + +typedef enum VkPerformanceCounterStorageKHR { + VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0, + VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1, + VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2, + VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3, + VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4, + VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5, + VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterStorageKHR; + +// Flag bits for VkPerformanceCounterDescriptionFlagBitsKHR +typedef VkFlags VkPerformanceCounterDescriptionFlagBitsKHR; +static constexpr VkPerformanceCounterDescriptionFlagBitsKHR VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR {0x00000001U}; +static constexpr VkPerformanceCounterDescriptionFlagBitsKHR VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR {0x00000002U}; +static constexpr VkPerformanceCounterDescriptionFlagBitsKHR VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR {VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR}; +static constexpr VkPerformanceCounterDescriptionFlagBitsKHR VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR {VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR}; + +typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR; + +// Flag bits for VkAcquireProfilingLockFlagBitsKHR +typedef VkFlags VkAcquireProfilingLockFlagBitsKHR; + +typedef VkFlags VkAcquireProfilingLockFlagsKHR; +typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 performanceCounterQueryPools; + VkBool32 performanceCounterMultipleQueryPools; +} VkPhysicalDevicePerformanceQueryFeaturesKHR; + +typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 allowCommandBufferQueryCopies; +} VkPhysicalDevicePerformanceQueryPropertiesKHR; + +typedef struct VkPerformanceCounterKHR { + VkStructureType sType; + void* pNext; + VkPerformanceCounterUnitKHR unit; + VkPerformanceCounterScopeKHR scope; + VkPerformanceCounterStorageKHR storage; + uint8_t uuid[VK_UUID_SIZE]; +} VkPerformanceCounterKHR; + +typedef struct VkPerformanceCounterDescriptionKHR { + VkStructureType sType; + void* pNext; + VkPerformanceCounterDescriptionFlagsKHR flags; + char name[VK_MAX_DESCRIPTION_SIZE]; + char category[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; +} VkPerformanceCounterDescriptionKHR; + +typedef struct VkQueryPoolPerformanceCreateInfoKHR { + VkStructureType sType; + void const* pNext; + uint32_t queueFamilyIndex; + uint32_t counterIndexCount; + uint32_t const* pCounterIndices; +} VkQueryPoolPerformanceCreateInfoKHR; + +typedef union VkPerformanceCounterResultKHR { + int32_t int32; + int64_t int64; + uint32_t uint32; + uint64_t uint64; + float float32; + double float64; +} VkPerformanceCounterResultKHR; + +typedef struct VkAcquireProfilingLockInfoKHR { + VkStructureType sType; + void const* pNext; + VkAcquireProfilingLockFlagsKHR flags; + uint64_t timeout; +} VkAcquireProfilingLockInfoKHR; + +typedef struct VkPerformanceQuerySubmitInfoKHR { + VkStructureType sType; + void const* pNext; + uint32_t counterPassIndex; +} VkPerformanceQuerySubmitInfoKHR; + +typedef struct VkPerformanceQueryReservationInfoKHR { + VkStructureType sType; + void const* pNext; + uint32_t maxPerformanceQueriesPerPool; +} VkPerformanceQueryReservationInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, VkQueryPoolPerformanceCreateInfoKHR const * pPerformanceQueryCreateInfo, uint32_t* pNumPasses); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireProfilingLockKHR)(VkDevice device, VkAcquireProfilingLockInfoKHR const * pInfo); +typedef void (VKAPI_PTR *PFN_vkReleaseProfilingLockKHR)(VkDevice device); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + uint32_t* pCounterCount, + VkPerformanceCounterKHR* pCounters, + VkPerformanceCounterDescriptionKHR* pCounterDescriptions); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( + VkPhysicalDevice physicalDevice, + VkQueryPoolPerformanceCreateInfoKHR const* pPerformanceQueryCreateInfo, + uint32_t* pNumPasses); + +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR( + VkDevice device, + VkAcquireProfilingLockInfoKHR const* pInfo); + +VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR( + VkDevice device); +#endif + + +#define VK_KHR_get_surface_capabilities2 1 +#define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1 +#define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2" +typedef struct VkPhysicalDeviceSurfaceInfo2KHR { + VkStructureType sType; + void const* pNext; + VkSurfaceKHR surface; +} VkPhysicalDeviceSurfaceInfo2KHR; + +typedef struct VkSurfaceCapabilities2KHR { + VkStructureType sType; + void* pNext; + VkSurfaceCapabilitiesKHR surfaceCapabilities; +} VkSurfaceCapabilities2KHR; + +typedef struct VkSurfaceFormat2KHR { + VkStructureType sType; + void* pNext; + VkSurfaceFormatKHR surfaceFormat; +} VkSurfaceFormat2KHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceSurfaceInfo2KHR const * pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceSurfaceInfo2KHR const * pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceSurfaceInfo2KHR const* pSurfaceInfo, + VkSurfaceCapabilities2KHR* pSurfaceCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceSurfaceInfo2KHR const* pSurfaceInfo, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormat2KHR* pSurfaceFormats); +#endif + + +#define VK_KHR_get_display_properties2 1 +#define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1 +#define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2" +typedef struct VkDisplayProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPropertiesKHR displayProperties; +} VkDisplayProperties2KHR; + +typedef struct VkDisplayPlaneProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPlanePropertiesKHR displayPlaneProperties; +} VkDisplayPlaneProperties2KHR; + +typedef struct VkDisplayModeProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayModePropertiesKHR displayModeProperties; +} VkDisplayModeProperties2KHR; + +typedef struct VkDisplayPlaneInfo2KHR { + VkStructureType sType; + void const* pNext; + VkDisplayModeKHR mode; + uint32_t planeIndex; +} VkDisplayPlaneInfo2KHR; + +typedef struct VkDisplayPlaneCapabilities2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPlaneCapabilitiesKHR capabilities; +} VkDisplayPlaneCapabilities2KHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, VkDisplayPlaneInfo2KHR const * pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayProperties2KHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlaneProperties2KHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModeProperties2KHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR( + VkPhysicalDevice physicalDevice, + VkDisplayPlaneInfo2KHR const* pDisplayPlaneInfo, + VkDisplayPlaneCapabilities2KHR* pCapabilities); +#endif + + +#define VK_KHR_shader_clock 1 +#define VK_KHR_SHADER_CLOCK_SPEC_VERSION 1 +#define VK_KHR_SHADER_CLOCK_EXTENSION_NAME "VK_KHR_shader_clock" +typedef struct VkPhysicalDeviceShaderClockFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderSubgroupClock; + VkBool32 shaderDeviceClock; +} VkPhysicalDeviceShaderClockFeaturesKHR; + + + +#define VK_KHR_swapchain_mutable_format 1 +#define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION 1 +#define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME "VK_KHR_swapchain_mutable_format" + + +#define VK_KHR_shader_terminate_invocation 1 +#define VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION 1 +#define VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME "VK_KHR_shader_terminate_invocation" +typedef struct VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderTerminateInvocation; +} VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR; + + + +#define VK_KHR_fragment_shading_rate 1 +#define VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION 2 +#define VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME "VK_KHR_fragment_shading_rate" + +typedef enum VkFragmentShadingRateCombinerOpKHR { + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR = 0, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR = 1, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR = 2, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR = 3, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR = 4, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_ENUM_KHR = 0x7FFFFFFF +} VkFragmentShadingRateCombinerOpKHR; +typedef struct VkFragmentShadingRateAttachmentInfoKHR { + VkStructureType sType; + void const* pNext; + VkAttachmentReference2 const* pFragmentShadingRateAttachment; + VkExtent2D shadingRateAttachmentTexelSize; +} VkFragmentShadingRateAttachmentInfoKHR; + +typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR { + VkStructureType sType; + void const* pNext; + VkExtent2D fragmentSize; + VkFragmentShadingRateCombinerOpKHR combinerOps[2]; +} VkPipelineFragmentShadingRateStateCreateInfoKHR; + +typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 pipelineFragmentShadingRate; + VkBool32 primitiveFragmentShadingRate; + VkBool32 attachmentFragmentShadingRate; +} VkPhysicalDeviceFragmentShadingRateFeaturesKHR; + +typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR { + VkStructureType sType; + void* pNext; + VkExtent2D minFragmentShadingRateAttachmentTexelSize; + VkExtent2D maxFragmentShadingRateAttachmentTexelSize; + uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio; + VkBool32 primitiveFragmentShadingRateWithMultipleViewports; + VkBool32 layeredShadingRateAttachments; + VkBool32 fragmentShadingRateNonTrivialCombinerOps; + VkExtent2D maxFragmentSize; + uint32_t maxFragmentSizeAspectRatio; + uint32_t maxFragmentShadingRateCoverageSamples; + VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples; + VkBool32 fragmentShadingRateWithShaderDepthStencilWrites; + VkBool32 fragmentShadingRateWithSampleMask; + VkBool32 fragmentShadingRateWithShaderSampleMask; + VkBool32 fragmentShadingRateWithConservativeRasterization; + VkBool32 fragmentShadingRateWithFragmentShaderInterlock; + VkBool32 fragmentShadingRateWithCustomSampleLocations; + VkBool32 fragmentShadingRateStrictMultiplyCombiner; +} VkPhysicalDeviceFragmentShadingRatePropertiesKHR; + +typedef struct VkPhysicalDeviceFragmentShadingRateKHR { + VkStructureType sType; + void* pNext; + VkSampleCountFlags sampleCounts; + VkExtent2D fragmentSize; +} VkPhysicalDeviceFragmentShadingRateKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); +typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateKHR)(VkCommandBuffer commandBuffer, VkExtent2D const * pFragmentSize, VkFragmentShadingRateCombinerOpKHR const combinerOps[2]); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceFragmentShadingRatesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pFragmentShadingRateCount, + VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR( + VkCommandBuffer commandBuffer, + VkExtent2D const* pFragmentSize, + VkFragmentShadingRateCombinerOpKHR const combinerOps[2]); +#endif + + +#define VK_KHR_object_refresh 1 +#define VK_KHR_OBJECT_REFRESH_SPEC_VERSION 1 +#define VK_KHR_OBJECT_REFRESH_EXTENSION_NAME "VK_KHR_object_refresh" + +// Flag bits for VkRefreshObjectFlagBitsKHR +typedef VkFlags VkRefreshObjectFlagBitsKHR; + +typedef VkFlags VkRefreshObjectFlagsKHR; +typedef struct VkRefreshObjectKHR { + VkObjectType objectType; + uint64_t objectHandle; + VkRefreshObjectFlagsKHR flags; +} VkRefreshObjectKHR; + +typedef struct VkRefreshObjectListKHR { + VkStructureType sType; + void const* pNext; + uint32_t objectCount; + VkRefreshObjectKHR const* pObjects; +} VkRefreshObjectListKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdRefreshObjectsKHR)(VkCommandBuffer commandBuffer, VkRefreshObjectListKHR const * pRefreshObjects); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceRefreshableObjectTypesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pRefreshableObjectTypeCount, VkObjectType* pRefreshableObjectTypes); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdRefreshObjectsKHR( + VkCommandBuffer commandBuffer, + VkRefreshObjectListKHR const* pRefreshObjects); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceRefreshableObjectTypesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pRefreshableObjectTypeCount, + VkObjectType* pRefreshableObjectTypes); +#endif + + +#define VK_KHR_synchronization2 1 +typedef uint64_t VkFlags64; +#define VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION 1 +#define VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME "VK_KHR_synchronization2" +typedef VkFlags64 VkPipelineStageFlags2KHR; + +// Flag bits for VkPipelineStageFlagBits2KHR +typedef VkFlags64 VkPipelineStageFlagBits2KHR; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_NONE_KHR {0ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR {0x00000001ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR {0x00000002ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR {0x00000004ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR {0x00000008ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR {0x00000010ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR {0x00000020ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR {0x00000040ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR {0x00000080ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR {0x00000100ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR {0x00000200ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR {0x00000400ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR {0x00000800ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR {0x00001000ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR {0x00002000ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_HOST_BIT_KHR {0x00004000ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR {0x00008000ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR {0x00010000ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COPY_BIT_KHR {0x100000000ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR {0x200000000ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_BLIT_BIT_KHR {0x400000000ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR {0x800000000ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR {0x1000000000ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR {0x2000000000ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR {0x4000000000ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT {0x01000000ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT {0x00040000ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV {0x00020000ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR {0x00400000ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR {0x02000000ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR {0x00200000ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT {0x00800000ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV {0x00080000ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV {0x00100000ULL}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR {VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV {VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV {VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR}; +static constexpr VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV {VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR}; + +typedef VkFlags64 VkAccessFlags2KHR; + +// Flag bits for VkAccessFlagBits2KHR +typedef VkFlags64 VkAccessFlagBits2KHR; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_NONE_KHR {0ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR {0x00000001ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_INDEX_READ_BIT_KHR {0x00000002ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR {0x00000004ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_UNIFORM_READ_BIT_KHR {0x00000008ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR {0x00000010ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_READ_BIT_KHR {0x00000020ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_WRITE_BIT_KHR {0x00000040ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR {0x00000080ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR {0x00000100ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR {0x00000200ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR {0x00000400ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFER_READ_BIT_KHR {0x00000800ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR {0x00001000ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_HOST_READ_BIT_KHR {0x00002000ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_HOST_WRITE_BIT_KHR {0x00004000ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_MEMORY_READ_BIT_KHR {0x00008000ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_MEMORY_WRITE_BIT_KHR {0x00010000ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR {0x100000000ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR {0x200000000ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR {0x400000000ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT {0x02000000ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT {0x04000000ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT {0x08000000ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT {0x00100000ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV {0x00020000ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV {0x00040000ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR {0x00800000ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR {0x00200000ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR {0x00400000ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT {0x01000000ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT {0x00080000ULL}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV {VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV {VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR}; +static constexpr VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV {VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR}; + + +// Flag bits for VkSubmitFlagBitsKHR +typedef VkFlags VkSubmitFlagBitsKHR; +static constexpr VkSubmitFlagBitsKHR VK_SUBMIT_PROTECTED_BIT_KHR {0x00000001U}; + +typedef VkFlags VkSubmitFlagsKHR; +typedef struct VkMemoryBarrier2KHR { + VkStructureType sType; + void const* pNext; + VkPipelineStageFlags2KHR srcStageMask; + VkAccessFlags2KHR srcAccessMask; + VkPipelineStageFlags2KHR dstStageMask; + VkAccessFlags2KHR dstAccessMask; +} VkMemoryBarrier2KHR; + +typedef struct VkBufferMemoryBarrier2KHR { + VkStructureType sType; + void const* pNext; + VkPipelineStageFlags2KHR srcStageMask; + VkAccessFlags2KHR srcAccessMask; + VkPipelineStageFlags2KHR dstStageMask; + VkAccessFlags2KHR dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} VkBufferMemoryBarrier2KHR; + +typedef struct VkImageMemoryBarrier2KHR { + VkStructureType sType; + void const* pNext; + VkPipelineStageFlags2KHR srcStageMask; + VkAccessFlags2KHR srcAccessMask; + VkPipelineStageFlags2KHR dstStageMask; + VkAccessFlags2KHR dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} VkImageMemoryBarrier2KHR; + +typedef struct VkDependencyInfoKHR { + VkStructureType sType; + void const* pNext; + VkDependencyFlags dependencyFlags; + uint32_t memoryBarrierCount; + VkMemoryBarrier2KHR const* pMemoryBarriers; + uint32_t bufferMemoryBarrierCount; + VkBufferMemoryBarrier2KHR const* pBufferMemoryBarriers; + uint32_t imageMemoryBarrierCount; + VkImageMemoryBarrier2KHR const* pImageMemoryBarriers; +} VkDependencyInfoKHR; + +typedef struct VkSemaphoreSubmitInfoKHR { + VkStructureType sType; + void const* pNext; + VkSemaphore semaphore; + uint64_t value; + VkPipelineStageFlags2KHR stageMask; + uint32_t deviceIndex; +} VkSemaphoreSubmitInfoKHR; + +typedef struct VkCommandBufferSubmitInfoKHR { + VkStructureType sType; + void const* pNext; + VkCommandBuffer commandBuffer; + uint32_t deviceMask; +} VkCommandBufferSubmitInfoKHR; + +typedef struct VkSubmitInfo2KHR { + VkStructureType sType; + void const* pNext; + VkSubmitFlagsKHR flags; + uint32_t waitSemaphoreInfoCount; + VkSemaphoreSubmitInfoKHR const* pWaitSemaphoreInfos; + uint32_t commandBufferInfoCount; + VkCommandBufferSubmitInfoKHR const* pCommandBufferInfos; + uint32_t signalSemaphoreInfoCount; + VkSemaphoreSubmitInfoKHR const* pSignalSemaphoreInfos; +} VkSubmitInfo2KHR; + +typedef struct VkPhysicalDeviceSynchronization2FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 synchronization2; +} VkPhysicalDeviceSynchronization2FeaturesKHR; + +typedef struct VkQueueFamilyCheckpointProperties2NV { + VkStructureType sType; + void* pNext; + VkPipelineStageFlags2KHR checkpointExecutionStageMask; +} VkQueueFamilyCheckpointProperties2NV; + +typedef struct VkCheckpointData2NV { + VkStructureType sType; + void* pNext; + VkPipelineStageFlags2KHR stage; + void* pCheckpointMarker; +} VkCheckpointData2NV; + +typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, VkDependencyInfoKHR const * pDependencyInfo); +typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2KHR stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents2KHR)(VkCommandBuffer commandBuffer, uint32_t eventCount, VkEvent const * pEvents, VkDependencyInfoKHR const * pDependencyInfos); +typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer commandBuffer, VkDependencyInfoKHR const * pDependencyInfo); +typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkQueryPool queryPool, uint32_t query); +typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2KHR)(VkQueue queue, uint32_t submitCount, VkSubmitInfo2KHR const * pSubmits, VkFence fence); +typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); +typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointData2NV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2KHR( + VkCommandBuffer commandBuffer, + VkEvent event, + VkDependencyInfoKHR const* pDependencyInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2KHR( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags2KHR stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2KHR( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + VkEvent const* pEvents, + VkDependencyInfoKHR const* pDependencyInfos); + +VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2KHR( + VkCommandBuffer commandBuffer, + VkDependencyInfoKHR const* pDependencyInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2KHR( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2KHR stage, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR( + VkQueue queue, + uint32_t submitCount, + VkSubmitInfo2KHR const* pSubmits, + VkFence fence); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarker2AMD( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2KHR stage, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + uint32_t marker); + +VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV( + VkQueue queue, + uint32_t* pCheckpointDataCount, + VkCheckpointData2NV* pCheckpointData); +#endif + + +#define VK_KHR_copy_commands2 1 +#define VK_KHR_COPY_COMMANDS_2_SPEC_VERSION 1 +#define VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME "VK_KHR_copy_commands2" +typedef struct VkBufferCopy2KHR { + VkStructureType sType; + void const* pNext; + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; +} VkBufferCopy2KHR; + +typedef struct VkCopyBufferInfo2KHR { + VkStructureType sType; + void const* pNext; + VkBuffer srcBuffer; + VkBuffer dstBuffer; + uint32_t regionCount; + VkBufferCopy2KHR const* pRegions; +} VkCopyBufferInfo2KHR; + +typedef struct VkImageCopy2KHR { + VkStructureType sType; + void const* pNext; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageCopy2KHR; + +typedef struct VkCopyImageInfo2KHR { + VkStructureType sType; + void const* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + VkImageCopy2KHR const* pRegions; +} VkCopyImageInfo2KHR; + +typedef struct VkBufferImageCopy2KHR { + VkStructureType sType; + void const* pNext; + VkDeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy2KHR; + +typedef struct VkCopyBufferToImageInfo2KHR { + VkStructureType sType; + void const* pNext; + VkBuffer srcBuffer; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + VkBufferImageCopy2KHR const* pRegions; +} VkCopyBufferToImageInfo2KHR; + +typedef struct VkCopyImageToBufferInfo2KHR { + VkStructureType sType; + void const* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkBuffer dstBuffer; + uint32_t regionCount; + VkBufferImageCopy2KHR const* pRegions; +} VkCopyImageToBufferInfo2KHR; + +typedef struct VkImageBlit2KHR { + VkStructureType sType; + void const* pNext; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffsets[2]; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffsets[2]; +} VkImageBlit2KHR; + +typedef struct VkBlitImageInfo2KHR { + VkStructureType sType; + void const* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + VkImageBlit2KHR const* pRegions; + VkFilter filter; +} VkBlitImageInfo2KHR; + +typedef struct VkImageResolve2KHR { + VkStructureType sType; + void const* pNext; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageResolve2KHR; + +typedef struct VkResolveImageInfo2KHR { + VkStructureType sType; + void const* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + VkImageResolve2KHR const* pRegions; +} VkResolveImageInfo2KHR; + +typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer2KHR)(VkCommandBuffer commandBuffer, VkCopyBufferInfo2KHR const * pCopyBufferInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2KHR)(VkCommandBuffer commandBuffer, VkCopyImageInfo2KHR const * pCopyImageInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage2KHR)(VkCommandBuffer commandBuffer, VkCopyBufferToImageInfo2KHR const * pCopyBufferToImageInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer commandBuffer, VkCopyImageToBufferInfo2KHR const * pCopyImageToBufferInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBlitImage2KHR)(VkCommandBuffer commandBuffer, VkBlitImageInfo2KHR const * pBlitImageInfo); +typedef void (VKAPI_PTR *PFN_vkCmdResolveImage2KHR)(VkCommandBuffer commandBuffer, VkResolveImageInfo2KHR const * pResolveImageInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2KHR( + VkCommandBuffer commandBuffer, + VkCopyBufferInfo2KHR const* pCopyBufferInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2KHR( + VkCommandBuffer commandBuffer, + VkCopyImageInfo2KHR const* pCopyImageInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2KHR( + VkCommandBuffer commandBuffer, + VkCopyBufferToImageInfo2KHR const* pCopyBufferToImageInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2KHR( + VkCommandBuffer commandBuffer, + VkCopyImageToBufferInfo2KHR const* pCopyImageToBufferInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2KHR( + VkCommandBuffer commandBuffer, + VkBlitImageInfo2KHR const* pBlitImageInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR( + VkCommandBuffer commandBuffer, + VkResolveImageInfo2KHR const* pResolveImageInfo); +#endif + + +#define VK_EXT_depth_range_unrestricted 1 +#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1 +#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted" + + +#define VK_EXT_texture_compression_astc_hdr 1 +#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION 1 +#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME "VK_EXT_texture_compression_astc_hdr" +typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 textureCompressionASTC_HDR; +} VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT; + + + +#define VK_EXT_astc_decode_mode 1 +#define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1 +#define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode" +typedef struct VkImageViewASTCDecodeModeEXT { + VkStructureType sType; + void const* pNext; + VkFormat decodeMode; +} VkImageViewASTCDecodeModeEXT; + +typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 decodeModeSharedExponent; +} VkPhysicalDeviceASTCDecodeFeaturesEXT; + + + +#define VK_EXT_direct_mode_display 1 +#define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1 +#define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display" +typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display); +#endif + + +#define VK_EXT_display_surface_counter 1 +#define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1 +#define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter" + +// Flag bits for VkSurfaceCounterFlagBitsEXT +typedef VkFlags VkSurfaceCounterFlagBitsEXT; +static constexpr VkSurfaceCounterFlagBitsEXT VK_SURFACE_COUNTER_VBLANK_BIT_EXT {0x00000001U}; +static constexpr VkSurfaceCounterFlagBitsEXT VK_SURFACE_COUNTER_VBLANK_EXT {VK_SURFACE_COUNTER_VBLANK_BIT_EXT}; + +typedef VkFlags VkSurfaceCounterFlagsEXT; +typedef struct VkSurfaceCapabilities2EXT { + VkStructureType sType; + void* pNext; + uint32_t minImageCount; + uint32_t maxImageCount; + VkExtent2D currentExtent; + VkExtent2D minImageExtent; + VkExtent2D maxImageExtent; + uint32_t maxImageArrayLayers; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkSurfaceTransformFlagBitsKHR currentTransform; + VkCompositeAlphaFlagsKHR supportedCompositeAlpha; + VkImageUsageFlags supportedUsageFlags; + VkSurfaceCounterFlagsEXT supportedSurfaceCounters; +} VkSurfaceCapabilities2EXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilities2EXT* pSurfaceCapabilities); +#endif + + +#define VK_EXT_display_control 1 +#define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1 +#define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control" + +typedef enum VkDisplayPowerStateEXT { + VK_DISPLAY_POWER_STATE_OFF_EXT = 0, + VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1, + VK_DISPLAY_POWER_STATE_ON_EXT = 2, + VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDisplayPowerStateEXT; + +typedef enum VkDeviceEventTypeEXT { + VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0, + VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceEventTypeEXT; + +typedef enum VkDisplayEventTypeEXT { + VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0, + VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDisplayEventTypeEXT; +typedef struct VkDisplayPowerInfoEXT { + VkStructureType sType; + void const* pNext; + VkDisplayPowerStateEXT powerState; +} VkDisplayPowerInfoEXT; + +typedef struct VkDeviceEventInfoEXT { + VkStructureType sType; + void const* pNext; + VkDeviceEventTypeEXT deviceEvent; +} VkDeviceEventInfoEXT; + +typedef struct VkDisplayEventInfoEXT { + VkStructureType sType; + void const* pNext; + VkDisplayEventTypeEXT displayEvent; +} VkDisplayEventInfoEXT; + +typedef struct VkSwapchainCounterCreateInfoEXT { + VkStructureType sType; + void const* pNext; + VkSurfaceCounterFlagsEXT surfaceCounters; +} VkSwapchainCounterCreateInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, VkDisplayPowerInfoEXT const * pDisplayPowerInfo); +typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, VkDeviceEventInfoEXT const * pDeviceEventInfo, VkAllocationCallbacks const * pAllocator, VkFence* pFence); +typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, VkDisplayEventInfoEXT const * pDisplayEventInfo, VkAllocationCallbacks const * pAllocator, VkFence* pFence); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT( + VkDevice device, + VkDisplayKHR display, + VkDisplayPowerInfoEXT const* pDisplayPowerInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT( + VkDevice device, + VkDeviceEventInfoEXT const* pDeviceEventInfo, + VkAllocationCallbacks const* pAllocator, + VkFence* pFence); + +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT( + VkDevice device, + VkDisplayKHR display, + VkDisplayEventInfoEXT const* pDisplayEventInfo, + VkAllocationCallbacks const* pAllocator, + VkFence* pFence); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT( + VkDevice device, + VkSwapchainKHR swapchain, + VkSurfaceCounterFlagBitsEXT counter, + uint64_t* pCounterValue); +#endif + + +#define VK_EXT_discard_rectangles 1 +#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1 +#define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles" + +typedef enum VkDiscardRectangleModeEXT { + VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0, + VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1, + VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDiscardRectangleModeEXT; +typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; +typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxDiscardRectangles; +} VkPhysicalDeviceDiscardRectanglePropertiesEXT; + +typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT { + VkStructureType sType; + void const* pNext; + VkPipelineDiscardRectangleStateCreateFlagsEXT flags; + VkDiscardRectangleModeEXT discardRectangleMode; + uint32_t discardRectangleCount; + VkRect2D const* pDiscardRectangles; +} VkPipelineDiscardRectangleStateCreateInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, VkRect2D const * pDiscardRectangles); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT( + VkCommandBuffer commandBuffer, + uint32_t firstDiscardRectangle, + uint32_t discardRectangleCount, + VkRect2D const* pDiscardRectangles); +#endif + + +#define VK_EXT_conservative_rasterization 1 +#define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1 +#define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization" + +typedef enum VkConservativeRasterizationModeEXT { + VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0, + VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1, + VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2, + VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkConservativeRasterizationModeEXT; +typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT; +typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT { + VkStructureType sType; + void* pNext; + float primitiveOverestimationSize; + float maxExtraPrimitiveOverestimationSize; + float extraPrimitiveOverestimationSizeGranularity; + VkBool32 primitiveUnderestimation; + VkBool32 conservativePointAndLineRasterization; + VkBool32 degenerateTrianglesRasterized; + VkBool32 degenerateLinesRasterized; + VkBool32 fullyCoveredFragmentShaderInputVariable; + VkBool32 conservativeRasterizationPostDepthCoverage; +} VkPhysicalDeviceConservativeRasterizationPropertiesEXT; + +typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT { + VkStructureType sType; + void const* pNext; + VkPipelineRasterizationConservativeStateCreateFlagsEXT flags; + VkConservativeRasterizationModeEXT conservativeRasterizationMode; + float extraPrimitiveOverestimationSize; +} VkPipelineRasterizationConservativeStateCreateInfoEXT; + + + +#define VK_EXT_depth_clip_enable 1 +#define VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION 1 +#define VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME "VK_EXT_depth_clip_enable" +typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT; +typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 depthClipEnable; +} VkPhysicalDeviceDepthClipEnableFeaturesEXT; + +typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT { + VkStructureType sType; + void const* pNext; + VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags; + VkBool32 depthClipEnable; +} VkPipelineRasterizationDepthClipStateCreateInfoEXT; + + + +#define VK_EXT_swapchain_colorspace 1 +#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 4 +#define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace" + + +#define VK_EXT_hdr_metadata 1 +#define VK_EXT_HDR_METADATA_SPEC_VERSION 2 +#define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata" +typedef struct VkXYColorEXT { + float x; + float y; +} VkXYColorEXT; + +typedef struct VkHdrMetadataEXT { + VkStructureType sType; + void const* pNext; + VkXYColorEXT displayPrimaryRed; + VkXYColorEXT displayPrimaryGreen; + VkXYColorEXT displayPrimaryBlue; + VkXYColorEXT whitePoint; + float maxLuminance; + float minLuminance; + float maxContentLightLevel; + float maxFrameAverageLightLevel; +} VkHdrMetadataEXT; + +typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, VkSwapchainKHR const * pSwapchains, VkHdrMetadataEXT const * pMetadata); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT( + VkDevice device, + uint32_t swapchainCount, + VkSwapchainKHR const* pSwapchains, + VkHdrMetadataEXT const* pMetadata); +#endif + + +#define VK_EXT_external_memory_dma_buf 1 +#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1 +#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf" + + +#define VK_EXT_queue_family_foreign 1 +#define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1 +#define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign" +static constexpr uint32_t VK_QUEUE_FAMILY_FOREIGN_EXT {~static_cast(2U)}; + + +#define VK_EXT_debug_utils 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT) +#define VK_EXT_DEBUG_UTILS_SPEC_VERSION 2 +#define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils" +typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT; + +// Flag bits for VkDebugUtilsMessageSeverityFlagBitsEXT +typedef VkFlags VkDebugUtilsMessageSeverityFlagBitsEXT; +static constexpr VkDebugUtilsMessageSeverityFlagBitsEXT VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT {0x00000001U}; +static constexpr VkDebugUtilsMessageSeverityFlagBitsEXT VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT {0x00000010U}; +static constexpr VkDebugUtilsMessageSeverityFlagBitsEXT VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT {0x00000100U}; +static constexpr VkDebugUtilsMessageSeverityFlagBitsEXT VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT {0x00001000U}; + + +// Flag bits for VkDebugUtilsMessageTypeFlagBitsEXT +typedef VkFlags VkDebugUtilsMessageTypeFlagBitsEXT; +static constexpr VkDebugUtilsMessageTypeFlagBitsEXT VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT {0x00000001U}; +static constexpr VkDebugUtilsMessageTypeFlagBitsEXT VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT {0x00000002U}; +static constexpr VkDebugUtilsMessageTypeFlagBitsEXT VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT {0x00000004U}; + +typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT; +typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT; +typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT; +typedef struct VkDebugUtilsLabelEXT { + VkStructureType sType; + void const* pNext; + char const* pLabelName; + float color[4]; +} VkDebugUtilsLabelEXT; + +typedef struct VkDebugUtilsObjectNameInfoEXT { + VkStructureType sType; + void const* pNext; + VkObjectType objectType; + uint64_t objectHandle; + char const* pObjectName; +} VkDebugUtilsObjectNameInfoEXT; + +typedef struct VkDebugUtilsMessengerCallbackDataEXT { + VkStructureType sType; + void const* pNext; + VkDebugUtilsMessengerCallbackDataFlagsEXT flags; + char const* pMessageIdName; + int32_t messageIdNumber; + char const* pMessage; + uint32_t queueLabelCount; + VkDebugUtilsLabelEXT const* pQueueLabels; + uint32_t cmdBufLabelCount; + VkDebugUtilsLabelEXT const* pCmdBufLabels; + uint32_t objectCount; + VkDebugUtilsObjectNameInfoEXT const* pObjects; +} VkDebugUtilsMessengerCallbackDataEXT; + +typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)( + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, + void* pUserData); + +typedef struct VkDebugUtilsMessengerCreateInfoEXT { + VkStructureType sType; + void const* pNext; + VkDebugUtilsMessengerCreateFlagsEXT flags; + VkDebugUtilsMessageSeverityFlagsEXT messageSeverity; + VkDebugUtilsMessageTypeFlagsEXT messageType; + PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback; + void* pUserData; +} VkDebugUtilsMessengerCreateInfoEXT; + +typedef struct VkDebugUtilsObjectTagInfoEXT { + VkStructureType sType; + void const* pNext; + VkObjectType objectType; + uint64_t objectHandle; + uint64_t tagName; + size_t tagSize; + void const* pTag; +} VkDebugUtilsObjectTagInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, VkDebugUtilsObjectNameInfoEXT const * pNameInfo); +typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, VkDebugUtilsObjectTagInfoEXT const * pTagInfo); +typedef void (VKAPI_PTR *PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, VkDebugUtilsLabelEXT const * pLabelInfo); +typedef void (VKAPI_PTR *PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue); +typedef void (VKAPI_PTR *PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, VkDebugUtilsLabelEXT const * pLabelInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, VkDebugUtilsLabelEXT const * pLabelInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, VkDebugUtilsLabelEXT const * pLabelInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerCreateInfoEXT const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkDebugUtilsMessengerEXT* pMessenger); +typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, VkAllocationCallbacks const * pAllocator); +typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, VkDebugUtilsMessengerCallbackDataEXT const * pCallbackData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT( + VkDevice device, + VkDebugUtilsObjectNameInfoEXT const* pNameInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT( + VkDevice device, + VkDebugUtilsObjectTagInfoEXT const* pTagInfo); + +VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT( + VkQueue queue, + VkDebugUtilsLabelEXT const* pLabelInfo); + +VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT( + VkQueue queue); + +VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT( + VkQueue queue, + VkDebugUtilsLabelEXT const* pLabelInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer, + VkDebugUtilsLabelEXT const* pLabelInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer, + VkDebugUtilsLabelEXT const* pLabelInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT( + VkInstance instance, + VkDebugUtilsMessengerCreateInfoEXT const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkDebugUtilsMessengerEXT* pMessenger); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT( + VkInstance instance, + VkDebugUtilsMessengerEXT messenger, + VkAllocationCallbacks const* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT( + VkInstance instance, + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + VkDebugUtilsMessengerCallbackDataEXT const* pCallbackData); +#endif + + +#define VK_EXT_shader_stencil_export 1 +#define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1 +#define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export" + + +#define VK_EXT_sample_locations 1 +#define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1 +#define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations" +typedef struct VkSampleLocationEXT { + float x; + float y; +} VkSampleLocationEXT; + +typedef struct VkSampleLocationsInfoEXT { + VkStructureType sType; + void const* pNext; + VkSampleCountFlagBits sampleLocationsPerPixel; + VkExtent2D sampleLocationGridSize; + uint32_t sampleLocationsCount; + VkSampleLocationEXT const* pSampleLocations; +} VkSampleLocationsInfoEXT; + +typedef struct VkAttachmentSampleLocationsEXT { + uint32_t attachmentIndex; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkAttachmentSampleLocationsEXT; + +typedef struct VkSubpassSampleLocationsEXT { + uint32_t subpassIndex; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkSubpassSampleLocationsEXT; + +typedef struct VkRenderPassSampleLocationsBeginInfoEXT { + VkStructureType sType; + void const* pNext; + uint32_t attachmentInitialSampleLocationsCount; + VkAttachmentSampleLocationsEXT const* pAttachmentInitialSampleLocations; + uint32_t postSubpassSampleLocationsCount; + VkSubpassSampleLocationsEXT const* pPostSubpassSampleLocations; +} VkRenderPassSampleLocationsBeginInfoEXT; + +typedef struct VkPipelineSampleLocationsStateCreateInfoEXT { + VkStructureType sType; + void const* pNext; + VkBool32 sampleLocationsEnable; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkPipelineSampleLocationsStateCreateInfoEXT; + +typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT { + VkStructureType sType; + void* pNext; + VkSampleCountFlags sampleLocationSampleCounts; + VkExtent2D maxSampleLocationGridSize; + float sampleLocationCoordinateRange[2]; + uint32_t sampleLocationSubPixelBits; + VkBool32 variableSampleLocations; +} VkPhysicalDeviceSampleLocationsPropertiesEXT; + +typedef struct VkMultisamplePropertiesEXT { + VkStructureType sType; + void* pNext; + VkExtent2D maxSampleLocationGridSize; +} VkMultisamplePropertiesEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, VkSampleLocationsInfoEXT const * pSampleLocationsInfo); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT( + VkCommandBuffer commandBuffer, + VkSampleLocationsInfoEXT const* pSampleLocationsInfo); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT( + VkPhysicalDevice physicalDevice, + VkSampleCountFlagBits samples, + VkMultisamplePropertiesEXT* pMultisampleProperties); +#endif + + +#define VK_EXT_blend_operation_advanced 1 +#define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2 +#define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced" + +typedef enum VkBlendOverlapEXT { + VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0, + VK_BLEND_OVERLAP_DISJOINT_EXT = 1, + VK_BLEND_OVERLAP_CONJOINT_EXT = 2, + VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF +} VkBlendOverlapEXT; +typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 advancedBlendCoherentOperations; +} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; + +typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t advancedBlendMaxColorAttachments; + VkBool32 advancedBlendIndependentBlend; + VkBool32 advancedBlendNonPremultipliedSrcColor; + VkBool32 advancedBlendNonPremultipliedDstColor; + VkBool32 advancedBlendCorrelatedOverlap; + VkBool32 advancedBlendAllOperations; +} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; + +typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT { + VkStructureType sType; + void const* pNext; + VkBool32 srcPremultiplied; + VkBool32 dstPremultiplied; + VkBlendOverlapEXT blendOverlap; +} VkPipelineColorBlendAdvancedStateCreateInfoEXT; + + + +#define VK_EXT_post_depth_coverage 1 +#define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1 +#define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage" + + +#define VK_EXT_image_drm_format_modifier 1 +#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 2 +#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME "VK_EXT_image_drm_format_modifier" +typedef VkFlags64 VkFormatFeatureFlags2KHR; + +// Flag bits for VkFormatFeatureFlagBits2KHR +typedef VkFlags64 VkFormatFeatureFlagBits2KHR; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR {0x00000001ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR {0x00000002ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR {0x00000004ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR {0x00000008ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR {0x00000010ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR {0x00000020ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR {0x00000040ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR {0x00000080ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR {0x00000100ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR {0x00000200ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR {0x00000400ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR {0x00000800ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR {0x00001000ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT {0x00002000ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR {0x00004000ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR {0x00008000ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR {0x00010000ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR {0x00020000ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR {0x00040000ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR {0x00080000ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR {0x00100000ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR {0x00200000ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR {0x00400000ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR {0x00800000ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR {0x80000000ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR {0x100000000ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR {0x200000000ULL}; +static constexpr VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR {0x40000000ULL}; + +typedef struct VkDrmFormatModifierPropertiesEXT { + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + VkFormatFeatureFlags drmFormatModifierTilingFeatures; +} VkDrmFormatModifierPropertiesEXT; + +typedef struct VkDrmFormatModifierPropertiesListEXT { + VkStructureType sType; + void* pNext; + uint32_t drmFormatModifierCount; + VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties; +} VkDrmFormatModifierPropertiesListEXT; + +typedef struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT { + VkStructureType sType; + void const* pNext; + uint64_t drmFormatModifier; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + uint32_t const* pQueueFamilyIndices; +} VkPhysicalDeviceImageDrmFormatModifierInfoEXT; + +typedef struct VkImageDrmFormatModifierListCreateInfoEXT { + VkStructureType sType; + void const* pNext; + uint32_t drmFormatModifierCount; + uint64_t const* pDrmFormatModifiers; +} VkImageDrmFormatModifierListCreateInfoEXT; + +typedef struct VkImageDrmFormatModifierExplicitCreateInfoEXT { + VkStructureType sType; + void const* pNext; + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + VkSubresourceLayout const* pPlaneLayouts; +} VkImageDrmFormatModifierExplicitCreateInfoEXT; + +typedef struct VkImageDrmFormatModifierPropertiesEXT { + VkStructureType sType; + void* pNext; + uint64_t drmFormatModifier; +} VkImageDrmFormatModifierPropertiesEXT; + +typedef struct VkDrmFormatModifierProperties2EXT { + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + VkFormatFeatureFlags2KHR drmFormatModifierTilingFeatures; +} VkDrmFormatModifierProperties2EXT; + +typedef struct VkDrmFormatModifierPropertiesList2EXT { + VkStructureType sType; + void* pNext; + uint32_t drmFormatModifierCount; + VkDrmFormatModifierProperties2EXT* pDrmFormatModifierProperties; +} VkDrmFormatModifierPropertiesList2EXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT( + VkDevice device, + VkImage image, + VkImageDrmFormatModifierPropertiesEXT* pProperties); +#endif + + +#define VK_EXT_filter_cubic 1 +#define VK_EXT_FILTER_CUBIC_SPEC_VERSION 3 +#define VK_EXT_FILTER_CUBIC_EXTENSION_NAME "VK_EXT_filter_cubic" +typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT { + VkStructureType sType; + void* pNext; + VkImageViewType imageViewType; +} VkPhysicalDeviceImageViewImageFormatInfoEXT; + +typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 filterCubic; + VkBool32 filterCubicMinmax; +} VkFilterCubicImageViewImageFormatPropertiesEXT; + + + +#define VK_EXT_global_priority 1 +#define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2 +#define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority" + +typedef enum VkQueueGlobalPriorityEXT { + VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128, + VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256, + VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512, + VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024, + VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_EXT = 0x7FFFFFFF +} VkQueueGlobalPriorityEXT; +typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT { + VkStructureType sType; + void const* pNext; + VkQueueGlobalPriorityEXT globalPriority; +} VkDeviceQueueGlobalPriorityCreateInfoEXT; + + + +#define VK_EXT_external_memory_host 1 +#define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1 +#define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host" +typedef struct VkImportMemoryHostPointerInfoEXT { + VkStructureType sType; + void const* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + void* pHostPointer; +} VkImportMemoryHostPointerInfoEXT; + +typedef struct VkMemoryHostPointerPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryHostPointerPropertiesEXT; + +typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize minImportedHostPointerAlignment; +} VkPhysicalDeviceExternalMemoryHostPropertiesEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, void const * pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + void const* pHostPointer, + VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); +#endif + + +#define VK_EXT_calibrated_timestamps 1 +#define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 2 +#define VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_EXT_calibrated_timestamps" + +typedef enum VkTimeDomainEXT { + VK_TIME_DOMAIN_DEVICE_EXT = 0, + VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1, + VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2, + VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3, + VK_TIME_DOMAIN_MAX_ENUM_EXT = 0x7FFFFFFF +} VkTimeDomainEXT; +typedef struct VkCalibratedTimestampInfoEXT { + VkStructureType sType; + void const* pNext; + VkTimeDomainEXT timeDomain; +} VkCalibratedTimestampInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains); +typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, VkCalibratedTimestampInfoEXT const * pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( + VkPhysicalDevice physicalDevice, + uint32_t* pTimeDomainCount, + VkTimeDomainEXT* pTimeDomains); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT( + VkDevice device, + uint32_t timestampCount, + VkCalibratedTimestampInfoEXT const* pTimestampInfos, + uint64_t* pTimestamps, + uint64_t* pMaxDeviation); +#endif + + +#define VK_EXT_vertex_attribute_divisor 1 +#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 3 +#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor" +typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxVertexAttribDivisor; +} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; + +typedef struct VkVertexInputBindingDivisorDescriptionEXT { + uint32_t binding; + uint32_t divisor; +} VkVertexInputBindingDivisorDescriptionEXT; + +typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT { + VkStructureType sType; + void const* pNext; + uint32_t vertexBindingDivisorCount; + VkVertexInputBindingDivisorDescriptionEXT const* pVertexBindingDivisors; +} VkPipelineVertexInputDivisorStateCreateInfoEXT; + +typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 vertexAttributeInstanceRateDivisor; + VkBool32 vertexAttributeInstanceRateZeroDivisor; +} VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT; + + + +#define VK_EXT_pci_bus_info 1 +#define VK_EXT_PCI_BUS_INFO_SPEC_VERSION 2 +#define VK_EXT_PCI_BUS_INFO_EXTENSION_NAME "VK_EXT_pci_bus_info" +typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t pciDomain; + uint32_t pciBus; + uint32_t pciDevice; + uint32_t pciFunction; +} VkPhysicalDevicePCIBusInfoPropertiesEXT; + + + +#define VK_EXT_subgroup_size_control 1 +#define VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION 2 +#define VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME "VK_EXT_subgroup_size_control" +typedef struct VkPhysicalDeviceSubgroupSizeControlFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 subgroupSizeControl; + VkBool32 computeFullSubgroups; +} VkPhysicalDeviceSubgroupSizeControlFeaturesEXT; + +typedef struct VkPhysicalDeviceSubgroupSizeControlPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t minSubgroupSize; + uint32_t maxSubgroupSize; + uint32_t maxComputeWorkgroupSubgroups; + VkShaderStageFlags requiredSubgroupSizeStages; +} VkPhysicalDeviceSubgroupSizeControlPropertiesEXT; + +typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT { + VkStructureType sType; + void* pNext; + uint32_t requiredSubgroupSize; +} VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT; + + + +#define VK_EXT_shader_image_atomic_int64 1 +#define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION 1 +#define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME "VK_EXT_shader_image_atomic_int64" +typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderImageInt64Atomics; + VkBool32 sparseImageInt64Atomics; +} VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT; + + + +#define VK_EXT_memory_budget 1 +#define VK_EXT_MEMORY_BUDGET_SPEC_VERSION 1 +#define VK_EXT_MEMORY_BUDGET_EXTENSION_NAME "VK_EXT_memory_budget" +typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize heapBudget[VK_MAX_MEMORY_HEAPS]; + VkDeviceSize heapUsage[VK_MAX_MEMORY_HEAPS]; +} VkPhysicalDeviceMemoryBudgetPropertiesEXT; + + + +#define VK_EXT_validation_features 1 +#define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 5 +#define VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME "VK_EXT_validation_features" + +typedef enum VkValidationFeatureEnableEXT { + VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0, + VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1, + VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2, + VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT = 3, + VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT = 4, + VK_VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationFeatureEnableEXT; + +typedef enum VkValidationFeatureDisableEXT { + VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0, + VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1, + VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2, + VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3, + VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4, + VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5, + VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6, + VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT = 7, + VK_VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationFeatureDisableEXT; +typedef struct VkValidationFeaturesEXT { + VkStructureType sType; + void const* pNext; + uint32_t enabledValidationFeatureCount; + VkValidationFeatureEnableEXT const* pEnabledValidationFeatures; + uint32_t disabledValidationFeatureCount; + VkValidationFeatureDisableEXT const* pDisabledValidationFeatures; +} VkValidationFeaturesEXT; + + + +#define VK_EXT_fragment_shader_interlock 1 +#define VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION 1 +#define VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME "VK_EXT_fragment_shader_interlock" +typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 fragmentShaderSampleInterlock; + VkBool32 fragmentShaderPixelInterlock; + VkBool32 fragmentShaderShadingRateInterlock; +} VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT; + + + +#define VK_EXT_ycbcr_image_arrays 1 +#define VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION 1 +#define VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME "VK_EXT_ycbcr_image_arrays" +typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 ycbcrImageArrays; +} VkPhysicalDeviceYcbcrImageArraysFeaturesEXT; + + + +#define VK_EXT_headless_surface 1 +#define VK_EXT_HEADLESS_SURFACE_SPEC_VERSION 1 +#define VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME "VK_EXT_headless_surface" +typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT; +typedef struct VkHeadlessSurfaceCreateInfoEXT { + VkStructureType sType; + void const* pNext; + VkHeadlessSurfaceCreateFlagsEXT flags; +} VkHeadlessSurfaceCreateInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, VkHeadlessSurfaceCreateInfoEXT const * pCreateInfo, VkAllocationCallbacks const * pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT( + VkInstance instance, + VkHeadlessSurfaceCreateInfoEXT const* pCreateInfo, + VkAllocationCallbacks const* pAllocator, + VkSurfaceKHR* pSurface); +#endif + + +#define VK_EXT_line_rasterization 1 +#define VK_EXT_LINE_RASTERIZATION_SPEC_VERSION 1 +#define VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME "VK_EXT_line_rasterization" + +typedef enum VkLineRasterizationModeEXT { + VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1, + VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3, + VK_LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkLineRasterizationModeEXT; +typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 rectangularLines; + VkBool32 bresenhamLines; + VkBool32 smoothLines; + VkBool32 stippledRectangularLines; + VkBool32 stippledBresenhamLines; + VkBool32 stippledSmoothLines; +} VkPhysicalDeviceLineRasterizationFeaturesEXT; + +typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t lineSubPixelPrecisionBits; +} VkPhysicalDeviceLineRasterizationPropertiesEXT; + +typedef struct VkPipelineRasterizationLineStateCreateInfoEXT { + VkStructureType sType; + void const* pNext; + VkLineRasterizationModeEXT lineRasterizationMode; + VkBool32 stippledLineEnable; + uint32_t lineStippleFactor; + uint16_t lineStipplePattern; +} VkPipelineRasterizationLineStateCreateInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT( + VkCommandBuffer commandBuffer, + uint32_t lineStippleFactor, + uint16_t lineStipplePattern); +#endif + + +#define VK_EXT_shader_atomic_float 1 +#define VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION 1 +#define VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME "VK_EXT_shader_atomic_float" +typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderBufferFloat32Atomics; + VkBool32 shaderBufferFloat32AtomicAdd; + VkBool32 shaderBufferFloat64Atomics; + VkBool32 shaderBufferFloat64AtomicAdd; + VkBool32 shaderSharedFloat32Atomics; + VkBool32 shaderSharedFloat32AtomicAdd; + VkBool32 shaderSharedFloat64Atomics; + VkBool32 shaderSharedFloat64AtomicAdd; + VkBool32 shaderImageFloat32Atomics; + VkBool32 shaderImageFloat32AtomicAdd; + VkBool32 sparseImageFloat32Atomics; + VkBool32 sparseImageFloat32AtomicAdd; +} VkPhysicalDeviceShaderAtomicFloatFeaturesEXT; + + + +#define VK_EXT_index_type_uint8 1 +#define VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION 1 +#define VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_EXT_index_type_uint8" +typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 indexTypeUint8; +} VkPhysicalDeviceIndexTypeUint8FeaturesEXT; + + + +#define VK_EXT_extended_dynamic_state 1 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION 1 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_extended_dynamic_state" +typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 extendedDynamicState; +} VkPhysicalDeviceExtendedDynamicStateFeaturesEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetCullModeEXT)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); +typedef void (VKAPI_PTR *PFN_vkCmdSetFrontFaceEXT)(VkCommandBuffer commandBuffer, VkFrontFace frontFace); +typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveTopologyEXT)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t viewportCount, VkViewport const * pViewports); +typedef void (VKAPI_PTR *PFN_vkCmdSetScissorWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t scissorCount, VkRect2D const * pScissors); +typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers2EXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, VkBuffer const * pBuffers, VkDeviceSize const * pOffsets, VkDeviceSize const * pSizes, VkDeviceSize const * pStrides); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthCompareOpEXT)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilOpEXT)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetCullModeEXT( + VkCommandBuffer commandBuffer, + VkCullModeFlags cullMode); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFaceEXT( + VkCommandBuffer commandBuffer, + VkFrontFace frontFace); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopologyEXT( + VkCommandBuffer commandBuffer, + VkPrimitiveTopology primitiveTopology); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCountEXT( + VkCommandBuffer commandBuffer, + uint32_t viewportCount, + VkViewport const* pViewports); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCountEXT( + VkCommandBuffer commandBuffer, + uint32_t scissorCount, + VkRect2D const* pScissors); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2EXT( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + VkBuffer const* pBuffers, + VkDeviceSize const* pOffsets, + VkDeviceSize const* pSizes, + VkDeviceSize const* pStrides); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthTestEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthWriteEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOpEXT( + VkCommandBuffer commandBuffer, + VkCompareOp depthCompareOp); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthBoundsTestEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 stencilTestEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOpEXT( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + VkStencilOp failOp, + VkStencilOp passOp, + VkStencilOp depthFailOp, + VkCompareOp compareOp); +#endif + + +#define VK_EXT_shader_demote_to_helper_invocation 1 +#define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION 1 +#define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME "VK_EXT_shader_demote_to_helper_invocation" +typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderDemoteToHelperInvocation; +} VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; + + + +#define VK_EXT_texel_buffer_alignment 1 +#define VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION 1 +#define VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME "VK_EXT_texel_buffer_alignment" +typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 texelBufferAlignment; +} VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT; + +typedef struct VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize storageTexelBufferOffsetAlignmentBytes; + VkBool32 storageTexelBufferOffsetSingleTexelAlignment; + VkDeviceSize uniformTexelBufferOffsetAlignmentBytes; + VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; +} VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT; + + + +#define VK_EXT_robustness2 1 +#define VK_EXT_ROBUSTNESS_2_SPEC_VERSION 1 +#define VK_EXT_ROBUSTNESS_2_EXTENSION_NAME "VK_EXT_robustness2" +typedef struct VkPhysicalDeviceRobustness2FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 robustBufferAccess2; + VkBool32 robustImageAccess2; + VkBool32 nullDescriptor; +} VkPhysicalDeviceRobustness2FeaturesEXT; + +typedef struct VkPhysicalDeviceRobustness2PropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize robustStorageBufferAccessSizeAlignment; + VkDeviceSize robustUniformBufferAccessSizeAlignment; +} VkPhysicalDeviceRobustness2PropertiesEXT; + + + +#define VK_EXT_custom_border_color 1 +#define VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION 12 +#define VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME "VK_EXT_custom_border_color" +typedef struct VkSamplerCustomBorderColorCreateInfoEXT { + VkStructureType sType; + void const* pNext; + VkClearColorValue customBorderColor; + VkFormat format; +} VkSamplerCustomBorderColorCreateInfoEXT; + +typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxCustomBorderColorSamplers; +} VkPhysicalDeviceCustomBorderColorPropertiesEXT; + +typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 customBorderColors; + VkBool32 customBorderColorWithoutFormat; +} VkPhysicalDeviceCustomBorderColorFeaturesEXT; + + + +#define VK_EXT_ycbcr_2plane_444_formats 1 +#define VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION 1 +#define VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME "VK_EXT_ycbcr_2plane_444_formats" +typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 ycbcr2plane444Formats; +} VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; + + + +#define VK_EXT_image_robustness 1 +#define VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION 1 +#define VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_image_robustness" +typedef struct VkPhysicalDeviceImageRobustnessFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 robustImageAccess; +} VkPhysicalDeviceImageRobustnessFeaturesEXT; + + + +#define VK_EXT_4444_formats 1 +#define VK_EXT_4444_FORMATS_SPEC_VERSION 1 +#define VK_EXT_4444_FORMATS_EXTENSION_NAME "VK_EXT_4444_formats" +typedef struct VkPhysicalDevice4444FormatsFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 formatA4R4G4B4; + VkBool32 formatA4B4G4R4; +} VkPhysicalDevice4444FormatsFeaturesEXT; + + + +#define VK_EXT_vertex_input_dynamic_state 1 +#define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION 2 +#define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_vertex_input_dynamic_state" +typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 vertexInputDynamicState; +} VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT; + +typedef struct VkVertexInputBindingDescription2EXT { + VkStructureType sType; + void* pNext; + uint32_t binding; + uint32_t stride; + VkVertexInputRate inputRate; + uint32_t divisor; +} VkVertexInputBindingDescription2EXT; + +typedef struct VkVertexInputAttributeDescription2EXT { + VkStructureType sType; + void* pNext; + uint32_t location; + uint32_t binding; + VkFormat format; + uint32_t offset; +} VkVertexInputAttributeDescription2EXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetVertexInputEXT)(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, VkVertexInputBindingDescription2EXT const * pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, VkVertexInputAttributeDescription2EXT const * pVertexAttributeDescriptions); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetVertexInputEXT( + VkCommandBuffer commandBuffer, + uint32_t vertexBindingDescriptionCount, + VkVertexInputBindingDescription2EXT const* pVertexBindingDescriptions, + uint32_t vertexAttributeDescriptionCount, + VkVertexInputAttributeDescription2EXT const* pVertexAttributeDescriptions); +#endif + + +#define VK_EXT_extended_dynamic_state2 1 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION 1 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME "VK_EXT_extended_dynamic_state2" +typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 extendedDynamicState2; + VkBool32 extendedDynamicState2LogicOp; + VkBool32 extendedDynamicState2PatchControlPoints; +} VkPhysicalDeviceExtendedDynamicState2FeaturesEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer commandBuffer, uint32_t patchControlPoints); +typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBiasEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer commandBuffer, VkLogicOp logicOp); +typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetPatchControlPointsEXT( + VkCommandBuffer commandBuffer, + uint32_t patchControlPoints); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 rasterizerDiscardEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthBiasEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEXT( + VkCommandBuffer commandBuffer, + VkLogicOp logicOp); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 primitiveRestartEnable); +#endif + + +#define VK_EXT_color_write_enable 1 +#define VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION 1 +#define VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME "VK_EXT_color_write_enable" +typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 colorWriteEnable; +} VkPhysicalDeviceColorWriteEnableFeaturesEXT; + +typedef struct VkPipelineColorWriteCreateInfoEXT { + VkStructureType sType; + void const* pNext; + uint32_t attachmentCount; + VkBool32 const* pColorWriteEnables; +} VkPipelineColorWriteCreateInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetColorWriteEnableEXT)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, VkBool32 const * pColorWriteEnables); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteEnableEXT( + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + VkBool32 const* pColorWriteEnables); +#endif + + +#define VK_EXT_application_parameters 1 +#define VK_EXT_APPLICATION_PARAMETERS_SPEC_VERSION 1 +#define VK_EXT_APPLICATION_PARAMETERS_EXTENSION_NAME "VK_EXT_application_parameters" +typedef struct VkApplicationParametersEXT { + VkStructureType sType; + void const* pNext; + uint32_t vendorID; + uint32_t deviceID; + uint32_t key; + uint64_t value; +} VkApplicationParametersEXT; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/vulkan/vulkan_screen.h b/include/vulkan/vulkan_screen.h new file mode 100644 index 0000000..36701ac --- /dev/null +++ b/include/vulkan/vulkan_screen.h @@ -0,0 +1,25 @@ +#ifndef VULKAN_SCREEN_H_ +#define VULKAN_SCREEN_H_ 1 + +/* +** Copyright 2015-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/vulkan/vulkan_vi.h b/include/vulkan/vulkan_vi.h new file mode 100644 index 0000000..1665ec0 --- /dev/null +++ b/include/vulkan/vulkan_vi.h @@ -0,0 +1,25 @@ +#ifndef VULKAN_VI_H_ +#define VULKAN_VI_H_ 1 + +/* +** Copyright 2015-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/vulkan/vulkan_wayland.h b/include/vulkan/vulkan_wayland.h new file mode 100644 index 0000000..6779ef9 --- /dev/null +++ b/include/vulkan/vulkan_wayland.h @@ -0,0 +1,25 @@ +#ifndef VULKAN_WAYLAND_H_ +#define VULKAN_WAYLAND_H_ 1 + +/* +** Copyright 2015-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/vulkan/vulkan_win32.h b/include/vulkan/vulkan_win32.h new file mode 100644 index 0000000..670c02d --- /dev/null +++ b/include/vulkan/vulkan_win32.h @@ -0,0 +1,25 @@ +#ifndef VULKAN_WIN32_H_ +#define VULKAN_WIN32_H_ 1 + +/* +** Copyright 2015-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/vulkan/vulkan_xcb.h b/include/vulkan/vulkan_xcb.h new file mode 100644 index 0000000..6e3751b --- /dev/null +++ b/include/vulkan/vulkan_xcb.h @@ -0,0 +1,25 @@ +#ifndef VULKAN_XCB_H_ +#define VULKAN_XCB_H_ 1 + +/* +** Copyright 2015-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/vulkan/vulkan_xlib.h b/include/vulkan/vulkan_xlib.h new file mode 100644 index 0000000..8ccb7f9 --- /dev/null +++ b/include/vulkan/vulkan_xlib.h @@ -0,0 +1,25 @@ +#ifndef VULKAN_XLIB_H_ +#define VULKAN_XLIB_H_ 1 + +/* +** Copyright 2015-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/vulkan/vulkan_xlib_xrandr.h b/include/vulkan/vulkan_xlib_xrandr.h new file mode 100644 index 0000000..a37ab88 --- /dev/null +++ b/include/vulkan/vulkan_xlib_xrandr.h @@ -0,0 +1,25 @@ +#ifndef VULKAN_XLIB_XRANDR_H_ +#define VULKAN_XLIB_XRANDR_H_ 1 + +/* +** Copyright 2015-2021 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/json/vk.json b/json/vk.json new file mode 100644 index 0000000..f845101 --- /dev/null +++ b/json/vk.json @@ -0,0 +1,5255 @@ +{ +"$schema": "http://json-schema.org/draft-04/schema#", +"id": "https://schema.khronos.org/vulkan/vk.json#", +"title": "JSON schema for Vulkan SC", +"description": "Schema for representing entire vk.xml as a schema.", +"type": "object", +"additionalProperties": true, +"definitions": { + "$schema": {"type": "string", "format": "uri"}, + "uint8_t": {"type": "integer", "minimum": 0, "maximum": 255}, + "int32_t": {"type": "integer", "minimum": -2147483648, "maximum": 2147483647}, + "uint32_t": {"type": "integer", "minimum": 0, "maximum": 4294967295}, + "uint64_t": {"oneOf": [{"enum": [""]},{"type": "integer"}]}, + "char": {"type": "string"}, + "float": {"type": "number"}, + "size_t": {"$ref": "#/definitions/uint32_t"}, + "enum": {"type": "string"}, + "void": {"enum": ["NULL", ""]}, + "VkBuffer": {"$ref": "#/definitions/uint64_t"}, + "VkImage": {"$ref": "#/definitions/uint64_t"}, + "VkInstance": {"$ref": "#/definitions/uint64_t"}, + "VkPhysicalDevice": {"$ref": "#/definitions/uint64_t"}, + "VkDevice": {"$ref": "#/definitions/uint64_t"}, + "VkQueue": {"$ref": "#/definitions/uint64_t"}, + "VkSemaphore": {"$ref": "#/definitions/uint64_t"}, + "VkCommandBuffer": {"$ref": "#/definitions/uint64_t"}, + "VkFence": {"$ref": "#/definitions/uint64_t"}, + "VkDeviceMemory": {"$ref": "#/definitions/uint64_t"}, + "VkEvent": {"$ref": "#/definitions/uint64_t"}, + "VkQueryPool": {"$ref": "#/definitions/uint64_t"}, + "VkBufferView": {"$ref": "#/definitions/uint64_t"}, + "VkImageView": {"$ref": "#/definitions/uint64_t"}, + "VkShaderModule": {"$ref": "#/definitions/uint64_t"}, + "VkPipelineCache": {"$ref": "#/definitions/uint64_t"}, + "VkPipelineLayout": {"$ref": "#/definitions/uint64_t"}, + "VkPipeline": {"$ref": "#/definitions/uint64_t"}, + "VkRenderPass": {"$ref": "#/definitions/uint64_t"}, + "VkDescriptorSetLayout": {"$ref": "#/definitions/uint64_t"}, + "VkSampler": {"$ref": "#/definitions/uint64_t"}, + "VkDescriptorSet": {"$ref": "#/definitions/uint64_t"}, + "VkDescriptorPool": {"$ref": "#/definitions/uint64_t"}, + "VkFramebuffer": {"$ref": "#/definitions/uint64_t"}, + "VkCommandPool": {"$ref": "#/definitions/uint64_t"}, + "VkResult": {"$ref": "#/definitions/enum"}, + "VkStructureType": {"$ref": "#/definitions/enum"}, + "VkAccessFlagBits": {"$ref": "#/definitions/enum"}, + "VkImageLayout": {"$ref": "#/definitions/enum"}, + "VkImageAspectFlagBits": {"$ref": "#/definitions/enum"}, + "VkObjectType": {"$ref": "#/definitions/enum"}, + "VkPipelineCacheHeaderVersion": {"$ref": "#/definitions/enum"}, + "VkVendorId": {"$ref": "#/definitions/enum"}, + "VkSystemAllocationScope": {"$ref": "#/definitions/enum"}, + "VkInternalAllocationType": {"$ref": "#/definitions/enum"}, + "VkFormat": {"$ref": "#/definitions/enum"}, + "VkFormatFeatureFlagBits": {"$ref": "#/definitions/enum"}, + "VkImageCreateFlagBits": {"$ref": "#/definitions/enum"}, + "VkSampleCountFlagBits": {"$ref": "#/definitions/enum"}, + "VkImageTiling": {"$ref": "#/definitions/enum"}, + "VkImageType": {"$ref": "#/definitions/enum"}, + "VkImageUsageFlagBits": {"$ref": "#/definitions/enum"}, + "VkMemoryHeapFlagBits": {"$ref": "#/definitions/enum"}, + "VkMemoryPropertyFlagBits": {"$ref": "#/definitions/enum"}, + "VkPhysicalDeviceType": {"$ref": "#/definitions/enum"}, + "VkQueueFlagBits": {"$ref": "#/definitions/enum"}, + "VkDeviceQueueCreateFlagBits": {"$ref": "#/definitions/enum"}, + "VkPipelineStageFlagBits": {"$ref": "#/definitions/enum"}, + "VkFenceCreateFlagBits": {"$ref": "#/definitions/enum"}, + "VkEventCreateFlagBits": {"$ref": "#/definitions/enum"}, + "VkQueryPipelineStatisticFlagBits": {"$ref": "#/definitions/enum"}, + "VkQueryType": {"$ref": "#/definitions/enum"}, + "VkQueryResultFlagBits": {"$ref": "#/definitions/enum"}, + "VkBufferCreateFlagBits": {"$ref": "#/definitions/enum"}, + "VkBufferUsageFlagBits": {"$ref": "#/definitions/enum"}, + "VkSharingMode": {"$ref": "#/definitions/enum"}, + "VkComponentSwizzle": {"$ref": "#/definitions/enum"}, + "VkImageViewCreateFlagBits": {"$ref": "#/definitions/enum"}, + "VkImageViewType": {"$ref": "#/definitions/enum"}, + "VkPipelineCacheCreateFlagBits": {"$ref": "#/definitions/enum"}, + "VkBlendFactor": {"$ref": "#/definitions/enum"}, + "VkBlendOp": {"$ref": "#/definitions/enum"}, + "VkColorComponentFlagBits": {"$ref": "#/definitions/enum"}, + "VkCompareOp": {"$ref": "#/definitions/enum"}, + "VkPipelineCreateFlagBits": {"$ref": "#/definitions/enum"}, + "VkPipelineShaderStageCreateFlagBits": {"$ref": "#/definitions/enum"}, + "VkShaderStageFlagBits": {"$ref": "#/definitions/enum"}, + "VkCullModeFlagBits": {"$ref": "#/definitions/enum"}, + "VkDynamicState": {"$ref": "#/definitions/enum"}, + "VkFrontFace": {"$ref": "#/definitions/enum"}, + "VkVertexInputRate": {"$ref": "#/definitions/enum"}, + "VkPrimitiveTopology": {"$ref": "#/definitions/enum"}, + "VkPolygonMode": {"$ref": "#/definitions/enum"}, + "VkStencilOp": {"$ref": "#/definitions/enum"}, + "VkLogicOp": {"$ref": "#/definitions/enum"}, + "VkBorderColor": {"$ref": "#/definitions/enum"}, + "VkFilter": {"$ref": "#/definitions/enum"}, + "VkSamplerAddressMode": {"$ref": "#/definitions/enum"}, + "VkSamplerCreateFlagBits": {"$ref": "#/definitions/enum"}, + "VkSamplerMipmapMode": {"$ref": "#/definitions/enum"}, + "VkDescriptorPoolCreateFlagBits": {"$ref": "#/definitions/enum"}, + "VkDescriptorType": {"$ref": "#/definitions/enum"}, + "VkDescriptorSetLayoutCreateFlagBits": {"$ref": "#/definitions/enum"}, + "VkAttachmentDescriptionFlagBits": {"$ref": "#/definitions/enum"}, + "VkAttachmentLoadOp": {"$ref": "#/definitions/enum"}, + "VkAttachmentStoreOp": {"$ref": "#/definitions/enum"}, + "VkDependencyFlagBits": {"$ref": "#/definitions/enum"}, + "VkFramebufferCreateFlagBits": {"$ref": "#/definitions/enum"}, + "VkPipelineBindPoint": {"$ref": "#/definitions/enum"}, + "VkRenderPassCreateFlagBits": {"$ref": "#/definitions/enum"}, + "VkSubpassDescriptionFlagBits": {"$ref": "#/definitions/enum"}, + "VkCommandPoolCreateFlagBits": {"$ref": "#/definitions/enum"}, + "VkCommandPoolResetFlagBits": {"$ref": "#/definitions/enum"}, + "VkCommandBufferLevel": {"$ref": "#/definitions/enum"}, + "VkCommandBufferUsageFlagBits": {"$ref": "#/definitions/enum"}, + "VkQueryControlFlagBits": {"$ref": "#/definitions/enum"}, + "VkCommandBufferResetFlagBits": {"$ref": "#/definitions/enum"}, + "VkIndexType": {"$ref": "#/definitions/enum"}, + "VkStencilFaceFlagBits": {"$ref": "#/definitions/enum"}, + "VkSubpassContents": {"$ref": "#/definitions/enum"}, + "VkBool32": {"oneOf": [{"$ref": "#/definitions/uint32_t"},{"enum": ["VK_TRUE", "VK_FALSE"]}]}, + "VkDeviceAddress": {"$ref": "#/definitions/uint64_t"}, + "VkDeviceSize": {"$ref": "#/definitions/uint64_t"}, + "VkFlags": {"oneOf": [{"$ref": "#/definitions/uint32_t"},{"$ref": "#/definitions/enum"}]}, + "VkAccessFlags": {"$ref": "#/definitions/VkFlags"}, + "VkImageAspectFlags": {"$ref": "#/definitions/VkFlags"}, + "VkFormatFeatureFlags": {"$ref": "#/definitions/VkFlags"}, + "VkImageCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkSampleCountFlags": {"$ref": "#/definitions/VkFlags"}, + "VkImageUsageFlags": {"$ref": "#/definitions/VkFlags"}, + "VkInstanceCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkMemoryHeapFlags": {"$ref": "#/definitions/VkFlags"}, + "VkMemoryPropertyFlags": {"$ref": "#/definitions/VkFlags"}, + "VkQueueFlags": {"$ref": "#/definitions/VkFlags"}, + "VkDeviceCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkDeviceQueueCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkPipelineStageFlags": {"$ref": "#/definitions/VkFlags"}, + "VkMemoryMapFlags": {"$ref": "#/definitions/VkFlags"}, + "VkFenceCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkSemaphoreCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkEventCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkQueryPipelineStatisticFlags": {"$ref": "#/definitions/VkFlags"}, + "VkQueryPoolCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkQueryResultFlags": {"$ref": "#/definitions/VkFlags"}, + "VkBufferCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkBufferUsageFlags": {"$ref": "#/definitions/VkFlags"}, + "VkBufferViewCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkImageViewCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkPipelineCacheCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkColorComponentFlags": {"$ref": "#/definitions/VkFlags"}, + "VkPipelineCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkPipelineShaderStageCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkCullModeFlags": {"$ref": "#/definitions/VkFlags"}, + "VkPipelineVertexInputStateCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkPipelineInputAssemblyStateCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkPipelineTessellationStateCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkPipelineViewportStateCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkPipelineRasterizationStateCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkPipelineMultisampleStateCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkSampleMask": {"$ref": "#/definitions/uint32_t"}, + "VkPipelineDepthStencilStateCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkPipelineColorBlendStateCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkPipelineDynamicStateCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkPipelineLayoutCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkShaderStageFlags": {"$ref": "#/definitions/VkFlags"}, + "VkSamplerCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkDescriptorPoolCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkDescriptorPoolResetFlags": {"$ref": "#/definitions/VkFlags"}, + "VkDescriptorSetLayoutCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkAttachmentDescriptionFlags": {"$ref": "#/definitions/VkFlags"}, + "VkDependencyFlags": {"$ref": "#/definitions/VkFlags"}, + "VkFramebufferCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkRenderPassCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkSubpassDescriptionFlags": {"$ref": "#/definitions/VkFlags"}, + "VkCommandPoolCreateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkCommandPoolResetFlags": {"$ref": "#/definitions/VkFlags"}, + "VkCommandBufferUsageFlags": {"$ref": "#/definitions/VkFlags"}, + "VkQueryControlFlags": {"$ref": "#/definitions/VkFlags"}, + "VkCommandBufferResetFlags": {"$ref": "#/definitions/VkFlags"}, + "VkStencilFaceFlags": {"$ref": "#/definitions/VkFlags"}, + "VkExtent2D": { + "type": "object", + "additionalProperties": false, + "properties": { + "width": {"$ref": "#/definitions/uint32_t"}, + "height": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkExtent3D": { + "type": "object", + "additionalProperties": false, + "properties": { + "width": {"$ref": "#/definitions/uint32_t"}, + "height": {"$ref": "#/definitions/uint32_t"}, + "depth": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkOffset2D": { + "type": "object", + "additionalProperties": false, + "properties": { + "x": {"$ref": "#/definitions/int32_t"}, + "y": {"$ref": "#/definitions/int32_t"} + } + }, + + "VkOffset3D": { + "type": "object", + "additionalProperties": false, + "properties": { + "x": {"$ref": "#/definitions/int32_t"}, + "y": {"$ref": "#/definitions/int32_t"}, + "z": {"$ref": "#/definitions/int32_t"} + } + }, + + "VkRect2D": { + "type": "object", + "additionalProperties": false, + "properties": { + "offset": {"$ref": "#/definitions/VkOffset2D"}, + "extent": {"$ref": "#/definitions/VkExtent2D"} + } + }, + + "VkBaseInStructure": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/VkBaseInStructure"} + } + }, + + "VkBaseOutStructure": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/VkBaseOutStructure"} + } + }, + + "VkBufferMemoryBarrier": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "srcAccessMask": {"$ref": "#/definitions/VkAccessFlags"}, + "dstAccessMask": {"$ref": "#/definitions/VkAccessFlags"}, + "srcQueueFamilyIndex": {"$ref": "#/definitions/uint32_t"}, + "dstQueueFamilyIndex": {"$ref": "#/definitions/uint32_t"}, + "buffer": {"$ref": "#/definitions/VkBuffer"}, + "offset": {"$ref": "#/definitions/VkDeviceSize"}, + "size": {"$ref": "#/definitions/VkDeviceSize"} + } + }, + + "VkDispatchIndirectCommand": { + "type": "object", + "additionalProperties": false, + "properties": { + "x": {"$ref": "#/definitions/uint32_t"}, + "y": {"$ref": "#/definitions/uint32_t"}, + "z": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkDrawIndexedIndirectCommand": { + "type": "object", + "additionalProperties": false, + "properties": { + "indexCount": {"$ref": "#/definitions/uint32_t"}, + "instanceCount": {"$ref": "#/definitions/uint32_t"}, + "firstIndex": {"$ref": "#/definitions/uint32_t"}, + "vertexOffset": {"$ref": "#/definitions/int32_t"}, + "firstInstance": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkDrawIndirectCommand": { + "type": "object", + "additionalProperties": false, + "properties": { + "vertexCount": {"$ref": "#/definitions/uint32_t"}, + "instanceCount": {"$ref": "#/definitions/uint32_t"}, + "firstVertex": {"$ref": "#/definitions/uint32_t"}, + "firstInstance": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkImageSubresourceRange": { + "type": "object", + "additionalProperties": false, + "properties": { + "aspectMask": {"$ref": "#/definitions/VkImageAspectFlags"}, + "baseMipLevel": {"$ref": "#/definitions/uint32_t"}, + "levelCount": {"$ref": "#/definitions/uint32_t"}, + "baseArrayLayer": {"$ref": "#/definitions/uint32_t"}, + "layerCount": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkImageMemoryBarrier": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "srcAccessMask": {"$ref": "#/definitions/VkAccessFlags"}, + "dstAccessMask": {"$ref": "#/definitions/VkAccessFlags"}, + "oldLayout": {"$ref": "#/definitions/VkImageLayout"}, + "newLayout": {"$ref": "#/definitions/VkImageLayout"}, + "srcQueueFamilyIndex": {"$ref": "#/definitions/uint32_t"}, + "dstQueueFamilyIndex": {"$ref": "#/definitions/uint32_t"}, + "image": {"$ref": "#/definitions/VkImage"}, + "subresourceRange": {"$ref": "#/definitions/VkImageSubresourceRange"} + } + }, + + "VkMemoryBarrier": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "srcAccessMask": {"$ref": "#/definitions/VkAccessFlags"}, + "dstAccessMask": {"$ref": "#/definitions/VkAccessFlags"} + } + }, + + "VkPipelineCacheHeaderVersionOne": { + "type": "object", + "additionalProperties": false, + "properties": { + "headerSize": {"$ref": "#/definitions/uint32_t"}, + "headerVersion": {"$ref": "#/definitions/VkPipelineCacheHeaderVersion"}, + "vendorID": {"$ref": "#/definitions/uint32_t"}, + "deviceID": {"$ref": "#/definitions/uint32_t"}, + "pipelineCacheUUID": {"$ref": "#/definitions/uint8_t"} + } + }, + + "VkAllocationCallbacks": { + "type": "object", + "additionalProperties": false, + "properties": { + "pUserData": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/void"}]}, + "pfnAllocation": {"$ref": "#/definitions/PFN_vkAllocationFunction"}, + "pfnReallocation": {"$ref": "#/definitions/PFN_vkReallocationFunction"}, + "pfnFree": {"$ref": "#/definitions/PFN_vkFreeFunction"}, + "pfnInternalAllocation": {"$ref": "#/definitions/PFN_vkInternalAllocationNotification"}, + "pfnInternalFree": {"$ref": "#/definitions/PFN_vkInternalFreeNotification"} + } + }, + + "VkApplicationInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "pApplicationName": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/char"}]}, + "applicationVersion": {"$ref": "#/definitions/uint32_t"}, + "pEngineName": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/char"}]}, + "engineVersion": {"$ref": "#/definitions/uint32_t"}, + "apiVersion": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkFormatProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "linearTilingFeatures": {"$ref": "#/definitions/VkFormatFeatureFlags"}, + "optimalTilingFeatures": {"$ref": "#/definitions/VkFormatFeatureFlags"}, + "bufferFeatures": {"$ref": "#/definitions/VkFormatFeatureFlags"} + } + }, + + "VkImageFormatProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "maxExtent": {"$ref": "#/definitions/VkExtent3D"}, + "maxMipLevels": {"$ref": "#/definitions/uint32_t"}, + "maxArrayLayers": {"$ref": "#/definitions/uint32_t"}, + "sampleCounts": {"$ref": "#/definitions/VkSampleCountFlags"}, + "maxResourceSize": {"$ref": "#/definitions/VkDeviceSize"} + } + }, + + "VkInstanceCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkInstanceCreateFlags"}, + "pApplicationInfo": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/VkApplicationInfo"}]}, + "enabledLayerCount": {"$ref": "#/definitions/uint32_t"}, + "ppEnabledLayerNames": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/char"}}]}, + "enabledExtensionCount": {"$ref": "#/definitions/uint32_t"}, + "ppEnabledExtensionNames": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/char"}}]} + } + }, + + "VkMemoryHeap": { + "type": "object", + "additionalProperties": false, + "properties": { + "size": {"$ref": "#/definitions/VkDeviceSize"}, + "flags": {"$ref": "#/definitions/VkMemoryHeapFlags"} + } + }, + + "VkMemoryType": { + "type": "object", + "additionalProperties": false, + "properties": { + "propertyFlags": {"$ref": "#/definitions/VkMemoryPropertyFlags"}, + "heapIndex": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkPhysicalDeviceFeatures": { + "type": "object", + "additionalProperties": false, + "properties": { + "robustBufferAccess": {"$ref": "#/definitions/VkBool32"}, + "fullDrawIndexUint32": {"$ref": "#/definitions/VkBool32"}, + "imageCubeArray": {"$ref": "#/definitions/VkBool32"}, + "independentBlend": {"$ref": "#/definitions/VkBool32"}, + "geometryShader": {"$ref": "#/definitions/VkBool32"}, + "tessellationShader": {"$ref": "#/definitions/VkBool32"}, + "sampleRateShading": {"$ref": "#/definitions/VkBool32"}, + "dualSrcBlend": {"$ref": "#/definitions/VkBool32"}, + "logicOp": {"$ref": "#/definitions/VkBool32"}, + "multiDrawIndirect": {"$ref": "#/definitions/VkBool32"}, + "drawIndirectFirstInstance": {"$ref": "#/definitions/VkBool32"}, + "depthClamp": {"$ref": "#/definitions/VkBool32"}, + "depthBiasClamp": {"$ref": "#/definitions/VkBool32"}, + "fillModeNonSolid": {"$ref": "#/definitions/VkBool32"}, + "depthBounds": {"$ref": "#/definitions/VkBool32"}, + "wideLines": {"$ref": "#/definitions/VkBool32"}, + "largePoints": {"$ref": "#/definitions/VkBool32"}, + "alphaToOne": {"$ref": "#/definitions/VkBool32"}, + "multiViewport": {"$ref": "#/definitions/VkBool32"}, + "samplerAnisotropy": {"$ref": "#/definitions/VkBool32"}, + "textureCompressionETC2": {"$ref": "#/definitions/VkBool32"}, + "textureCompressionASTC_LDR": {"$ref": "#/definitions/VkBool32"}, + "textureCompressionBC": {"$ref": "#/definitions/VkBool32"}, + "occlusionQueryPrecise": {"$ref": "#/definitions/VkBool32"}, + "pipelineStatisticsQuery": {"$ref": "#/definitions/VkBool32"}, + "vertexPipelineStoresAndAtomics": {"$ref": "#/definitions/VkBool32"}, + "fragmentStoresAndAtomics": {"$ref": "#/definitions/VkBool32"}, + "shaderTessellationAndGeometryPointSize": {"$ref": "#/definitions/VkBool32"}, + "shaderImageGatherExtended": {"$ref": "#/definitions/VkBool32"}, + "shaderStorageImageExtendedFormats": {"$ref": "#/definitions/VkBool32"}, + "shaderStorageImageMultisample": {"$ref": "#/definitions/VkBool32"}, + "shaderStorageImageReadWithoutFormat": {"$ref": "#/definitions/VkBool32"}, + "shaderStorageImageWriteWithoutFormat": {"$ref": "#/definitions/VkBool32"}, + "shaderUniformBufferArrayDynamicIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderSampledImageArrayDynamicIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderStorageBufferArrayDynamicIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderStorageImageArrayDynamicIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderClipDistance": {"$ref": "#/definitions/VkBool32"}, + "shaderCullDistance": {"$ref": "#/definitions/VkBool32"}, + "shaderFloat64": {"$ref": "#/definitions/VkBool32"}, + "shaderInt64": {"$ref": "#/definitions/VkBool32"}, + "shaderInt16": {"$ref": "#/definitions/VkBool32"}, + "shaderResourceResidency": {"$ref": "#/definitions/VkBool32"}, + "shaderResourceMinLod": {"$ref": "#/definitions/VkBool32"}, + "sparseBinding": {"$ref": "#/definitions/VkBool32"}, + "sparseResidencyBuffer": {"$ref": "#/definitions/VkBool32"}, + "sparseResidencyImage2D": {"$ref": "#/definitions/VkBool32"}, + "sparseResidencyImage3D": {"$ref": "#/definitions/VkBool32"}, + "sparseResidency2Samples": {"$ref": "#/definitions/VkBool32"}, + "sparseResidency4Samples": {"$ref": "#/definitions/VkBool32"}, + "sparseResidency8Samples": {"$ref": "#/definitions/VkBool32"}, + "sparseResidency16Samples": {"$ref": "#/definitions/VkBool32"}, + "sparseResidencyAliased": {"$ref": "#/definitions/VkBool32"}, + "variableMultisampleRate": {"$ref": "#/definitions/VkBool32"}, + "inheritedQueries": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceLimits": { + "type": "object", + "additionalProperties": false, + "properties": { + "maxImageDimension1D": {"$ref": "#/definitions/uint32_t"}, + "maxImageDimension2D": {"$ref": "#/definitions/uint32_t"}, + "maxImageDimension3D": {"$ref": "#/definitions/uint32_t"}, + "maxImageDimensionCube": {"$ref": "#/definitions/uint32_t"}, + "maxImageArrayLayers": {"$ref": "#/definitions/uint32_t"}, + "maxTexelBufferElements": {"$ref": "#/definitions/uint32_t"}, + "maxUniformBufferRange": {"$ref": "#/definitions/uint32_t"}, + "maxStorageBufferRange": {"$ref": "#/definitions/uint32_t"}, + "maxPushConstantsSize": {"$ref": "#/definitions/uint32_t"}, + "maxMemoryAllocationCount": {"$ref": "#/definitions/uint32_t"}, + "maxSamplerAllocationCount": {"$ref": "#/definitions/uint32_t"}, + "bufferImageGranularity": {"$ref": "#/definitions/VkDeviceSize"}, + "sparseAddressSpaceSize": {"$ref": "#/definitions/VkDeviceSize"}, + "maxBoundDescriptorSets": {"$ref": "#/definitions/uint32_t"}, + "maxPerStageDescriptorSamplers": {"$ref": "#/definitions/uint32_t"}, + "maxPerStageDescriptorUniformBuffers": {"$ref": "#/definitions/uint32_t"}, + "maxPerStageDescriptorStorageBuffers": {"$ref": "#/definitions/uint32_t"}, + "maxPerStageDescriptorSampledImages": {"$ref": "#/definitions/uint32_t"}, + "maxPerStageDescriptorStorageImages": {"$ref": "#/definitions/uint32_t"}, + "maxPerStageDescriptorInputAttachments": {"$ref": "#/definitions/uint32_t"}, + "maxPerStageResources": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetSamplers": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetUniformBuffers": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetUniformBuffersDynamic": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetStorageBuffers": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetStorageBuffersDynamic": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetSampledImages": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetStorageImages": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetInputAttachments": {"$ref": "#/definitions/uint32_t"}, + "maxVertexInputAttributes": {"$ref": "#/definitions/uint32_t"}, + "maxVertexInputBindings": {"$ref": "#/definitions/uint32_t"}, + "maxVertexInputAttributeOffset": {"$ref": "#/definitions/uint32_t"}, + "maxVertexInputBindingStride": {"$ref": "#/definitions/uint32_t"}, + "maxVertexOutputComponents": {"$ref": "#/definitions/uint32_t"}, + "maxTessellationGenerationLevel": {"$ref": "#/definitions/uint32_t"}, + "maxTessellationPatchSize": {"$ref": "#/definitions/uint32_t"}, + "maxTessellationControlPerVertexInputComponents": {"$ref": "#/definitions/uint32_t"}, + "maxTessellationControlPerVertexOutputComponents": {"$ref": "#/definitions/uint32_t"}, + "maxTessellationControlPerPatchOutputComponents": {"$ref": "#/definitions/uint32_t"}, + "maxTessellationControlTotalOutputComponents": {"$ref": "#/definitions/uint32_t"}, + "maxTessellationEvaluationInputComponents": {"$ref": "#/definitions/uint32_t"}, + "maxTessellationEvaluationOutputComponents": {"$ref": "#/definitions/uint32_t"}, + "maxGeometryShaderInvocations": {"$ref": "#/definitions/uint32_t"}, + "maxGeometryInputComponents": {"$ref": "#/definitions/uint32_t"}, + "maxGeometryOutputComponents": {"$ref": "#/definitions/uint32_t"}, + "maxGeometryOutputVertices": {"$ref": "#/definitions/uint32_t"}, + "maxGeometryTotalOutputComponents": {"$ref": "#/definitions/uint32_t"}, + "maxFragmentInputComponents": {"$ref": "#/definitions/uint32_t"}, + "maxFragmentOutputAttachments": {"$ref": "#/definitions/uint32_t"}, + "maxFragmentDualSrcAttachments": {"$ref": "#/definitions/uint32_t"}, + "maxFragmentCombinedOutputResources": {"$ref": "#/definitions/uint32_t"}, + "maxComputeSharedMemorySize": {"$ref": "#/definitions/uint32_t"}, + "maxComputeWorkGroupCount": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}}, + "maxComputeWorkGroupInvocations": {"$ref": "#/definitions/uint32_t"}, + "maxComputeWorkGroupSize": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}}, + "subPixelPrecisionBits": {"$ref": "#/definitions/uint32_t"}, + "subTexelPrecisionBits": {"$ref": "#/definitions/uint32_t"}, + "mipmapPrecisionBits": {"$ref": "#/definitions/uint32_t"}, + "maxDrawIndexedIndexValue": {"$ref": "#/definitions/uint32_t"}, + "maxDrawIndirectCount": {"$ref": "#/definitions/uint32_t"}, + "maxSamplerLodBias": {"$ref": "#/definitions/float"}, + "maxSamplerAnisotropy": {"$ref": "#/definitions/float"}, + "maxViewports": {"$ref": "#/definitions/uint32_t"}, + "maxViewportDimensions": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}}, + "viewportBoundsRange": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/float"}}, + "viewportSubPixelBits": {"$ref": "#/definitions/uint32_t"}, + "minMemoryMapAlignment": {"$ref": "#/definitions/size_t"}, + "minTexelBufferOffsetAlignment": {"$ref": "#/definitions/VkDeviceSize"}, + "minUniformBufferOffsetAlignment": {"$ref": "#/definitions/VkDeviceSize"}, + "minStorageBufferOffsetAlignment": {"$ref": "#/definitions/VkDeviceSize"}, + "minTexelOffset": {"$ref": "#/definitions/int32_t"}, + "maxTexelOffset": {"$ref": "#/definitions/uint32_t"}, + "minTexelGatherOffset": {"$ref": "#/definitions/int32_t"}, + "maxTexelGatherOffset": {"$ref": "#/definitions/uint32_t"}, + "minInterpolationOffset": {"$ref": "#/definitions/float"}, + "maxInterpolationOffset": {"$ref": "#/definitions/float"}, + "subPixelInterpolationOffsetBits": {"$ref": "#/definitions/uint32_t"}, + "maxFramebufferWidth": {"$ref": "#/definitions/uint32_t"}, + "maxFramebufferHeight": {"$ref": "#/definitions/uint32_t"}, + "maxFramebufferLayers": {"$ref": "#/definitions/uint32_t"}, + "framebufferColorSampleCounts": {"$ref": "#/definitions/VkSampleCountFlags"}, + "framebufferDepthSampleCounts": {"$ref": "#/definitions/VkSampleCountFlags"}, + "framebufferStencilSampleCounts": {"$ref": "#/definitions/VkSampleCountFlags"}, + "framebufferNoAttachmentsSampleCounts": {"$ref": "#/definitions/VkSampleCountFlags"}, + "maxColorAttachments": {"$ref": "#/definitions/uint32_t"}, + "sampledImageColorSampleCounts": {"$ref": "#/definitions/VkSampleCountFlags"}, + "sampledImageIntegerSampleCounts": {"$ref": "#/definitions/VkSampleCountFlags"}, + "sampledImageDepthSampleCounts": {"$ref": "#/definitions/VkSampleCountFlags"}, + "sampledImageStencilSampleCounts": {"$ref": "#/definitions/VkSampleCountFlags"}, + "storageImageSampleCounts": {"$ref": "#/definitions/VkSampleCountFlags"}, + "maxSampleMaskWords": {"$ref": "#/definitions/uint32_t"}, + "timestampComputeAndGraphics": {"$ref": "#/definitions/VkBool32"}, + "timestampPeriod": {"$ref": "#/definitions/float"}, + "maxClipDistances": {"$ref": "#/definitions/uint32_t"}, + "maxCullDistances": {"$ref": "#/definitions/uint32_t"}, + "maxCombinedClipAndCullDistances": {"$ref": "#/definitions/uint32_t"}, + "discreteQueuePriorities": {"$ref": "#/definitions/uint32_t"}, + "pointSizeRange": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/float"}}, + "lineWidthRange": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/float"}}, + "pointSizeGranularity": {"$ref": "#/definitions/float"}, + "lineWidthGranularity": {"$ref": "#/definitions/float"}, + "strictLines": {"$ref": "#/definitions/VkBool32"}, + "standardSampleLocations": {"$ref": "#/definitions/VkBool32"}, + "optimalBufferCopyOffsetAlignment": {"$ref": "#/definitions/VkDeviceSize"}, + "optimalBufferCopyRowPitchAlignment": {"$ref": "#/definitions/VkDeviceSize"}, + "nonCoherentAtomSize": {"$ref": "#/definitions/VkDeviceSize"} + } + }, + + "VkPhysicalDeviceMemoryProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "memoryTypeCount": {"$ref": "#/definitions/uint32_t"}, + "memoryTypes": {"$ref": "#/definitions/VkMemoryType"}, + "memoryHeapCount": {"$ref": "#/definitions/uint32_t"}, + "memoryHeaps": {"$ref": "#/definitions/VkMemoryHeap"} + } + }, + + "VkPhysicalDeviceSparseProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "residencyStandard2DBlockShape": {"$ref": "#/definitions/VkBool32"}, + "residencyStandard2DMultisampleBlockShape": {"$ref": "#/definitions/VkBool32"}, + "residencyStandard3DBlockShape": {"$ref": "#/definitions/VkBool32"}, + "residencyAlignedMipSize": {"$ref": "#/definitions/VkBool32"}, + "residencyNonResidentStrict": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "apiVersion": {"$ref": "#/definitions/uint32_t"}, + "driverVersion": {"$ref": "#/definitions/uint32_t"}, + "vendorID": {"$ref": "#/definitions/uint32_t"}, + "deviceID": {"$ref": "#/definitions/uint32_t"}, + "deviceType": {"$ref": "#/definitions/VkPhysicalDeviceType"}, + "deviceName": {"$ref": "#/definitions/char"}, + "pipelineCacheUUID": {"$ref": "#/definitions/uint8_t"}, + "limits": {"$ref": "#/definitions/VkPhysicalDeviceLimits"}, + "sparseProperties": {"$ref": "#/definitions/VkPhysicalDeviceSparseProperties"} + } + }, + + "VkQueueFamilyProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "queueFlags": {"$ref": "#/definitions/VkQueueFlags"}, + "queueCount": {"$ref": "#/definitions/uint32_t"}, + "timestampValidBits": {"$ref": "#/definitions/uint32_t"}, + "minImageTransferGranularity": {"$ref": "#/definitions/VkExtent3D"} + } + }, + + "VkDeviceQueueCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkDeviceQueueCreateFlags"}, + "queueFamilyIndex": {"$ref": "#/definitions/uint32_t"}, + "queueCount": {"$ref": "#/definitions/uint32_t"}, + "pQueuePriorities": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/float"}}]} + } + }, + + "VkDeviceCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkDeviceCreateFlags"}, + "queueCreateInfoCount": {"$ref": "#/definitions/uint32_t"}, + "pQueueCreateInfos": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkDeviceQueueCreateInfo"}}]}, + "enabledLayerCount": {"$ref": "#/definitions/uint32_t"}, + "ppEnabledLayerNames": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/char"}}]}, + "enabledExtensionCount": {"$ref": "#/definitions/uint32_t"}, + "ppEnabledExtensionNames": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/char"}}]}, + "pEnabledFeatures": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/VkPhysicalDeviceFeatures"}]} + } + }, + + "VkExtensionProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "extensionName": {"$ref": "#/definitions/char"}, + "specVersion": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkLayerProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "layerName": {"$ref": "#/definitions/char"}, + "specVersion": {"$ref": "#/definitions/uint32_t"}, + "implementationVersion": {"$ref": "#/definitions/uint32_t"}, + "description": {"$ref": "#/definitions/char"} + } + }, + + "VkSubmitInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "waitSemaphoreCount": {"$ref": "#/definitions/uint32_t"}, + "pWaitSemaphores": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkSemaphore"}}]}, + "pWaitDstStageMask": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkPipelineStageFlags"}}]}, + "commandBufferCount": {"$ref": "#/definitions/uint32_t"}, + "pCommandBuffers": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkCommandBuffer"}}]}, + "signalSemaphoreCount": {"$ref": "#/definitions/uint32_t"}, + "pSignalSemaphores": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkSemaphore"}}]} + } + }, + + "VkMappedMemoryRange": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "memory": {"$ref": "#/definitions/VkDeviceMemory"}, + "offset": {"$ref": "#/definitions/VkDeviceSize"}, + "size": {"$ref": "#/definitions/VkDeviceSize"} + } + }, + + "VkMemoryAllocateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "allocationSize": {"$ref": "#/definitions/VkDeviceSize"}, + "memoryTypeIndex": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkMemoryRequirements": { + "type": "object", + "additionalProperties": false, + "properties": { + "size": {"$ref": "#/definitions/VkDeviceSize"}, + "alignment": {"$ref": "#/definitions/VkDeviceSize"}, + "memoryTypeBits": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkImageSubresource": { + "type": "object", + "additionalProperties": false, + "properties": { + "aspectMask": {"$ref": "#/definitions/VkImageAspectFlags"}, + "mipLevel": {"$ref": "#/definitions/uint32_t"}, + "arrayLayer": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkFenceCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkFenceCreateFlags"} + } + }, + + "VkSemaphoreCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkSemaphoreCreateFlags"} + } + }, + + "VkEventCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkEventCreateFlags"} + } + }, + + "VkQueryPoolCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkQueryPoolCreateFlags"}, + "queryType": {"$ref": "#/definitions/VkQueryType"}, + "queryCount": {"$ref": "#/definitions/uint32_t"}, + "pipelineStatistics": {"$ref": "#/definitions/VkQueryPipelineStatisticFlags"} + } + }, + + "VkBufferCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkBufferCreateFlags"}, + "size": {"$ref": "#/definitions/VkDeviceSize"}, + "usage": {"$ref": "#/definitions/VkBufferUsageFlags"}, + "sharingMode": {"$ref": "#/definitions/VkSharingMode"}, + "queueFamilyIndexCount": {"$ref": "#/definitions/uint32_t"}, + "pQueueFamilyIndices": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}}]} + } + }, + + "VkBufferViewCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkBufferViewCreateFlags"}, + "buffer": {"$ref": "#/definitions/VkBuffer"}, + "format": {"$ref": "#/definitions/VkFormat"}, + "offset": {"$ref": "#/definitions/VkDeviceSize"}, + "range": {"$ref": "#/definitions/VkDeviceSize"} + } + }, + + "VkImageCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkImageCreateFlags"}, + "imageType": {"$ref": "#/definitions/VkImageType"}, + "format": {"$ref": "#/definitions/VkFormat"}, + "extent": {"$ref": "#/definitions/VkExtent3D"}, + "mipLevels": {"$ref": "#/definitions/uint32_t"}, + "arrayLayers": {"$ref": "#/definitions/uint32_t"}, + "samples": {"$ref": "#/definitions/VkSampleCountFlagBits"}, + "tiling": {"$ref": "#/definitions/VkImageTiling"}, + "usage": {"$ref": "#/definitions/VkImageUsageFlags"}, + "sharingMode": {"$ref": "#/definitions/VkSharingMode"}, + "queueFamilyIndexCount": {"$ref": "#/definitions/uint32_t"}, + "pQueueFamilyIndices": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}}]}, + "initialLayout": {"$ref": "#/definitions/VkImageLayout"} + } + }, + + "VkSubresourceLayout": { + "type": "object", + "additionalProperties": false, + "properties": { + "offset": {"$ref": "#/definitions/VkDeviceSize"}, + "size": {"$ref": "#/definitions/VkDeviceSize"}, + "rowPitch": {"$ref": "#/definitions/VkDeviceSize"}, + "arrayPitch": {"$ref": "#/definitions/VkDeviceSize"}, + "depthPitch": {"$ref": "#/definitions/VkDeviceSize"} + } + }, + + "VkComponentMapping": { + "type": "object", + "additionalProperties": false, + "properties": { + "r": {"$ref": "#/definitions/VkComponentSwizzle"}, + "g": {"$ref": "#/definitions/VkComponentSwizzle"}, + "b": {"$ref": "#/definitions/VkComponentSwizzle"}, + "a": {"$ref": "#/definitions/VkComponentSwizzle"} + } + }, + + "VkImageViewCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkImageViewCreateFlags"}, + "image": {"$ref": "#/definitions/VkImage"}, + "viewType": {"$ref": "#/definitions/VkImageViewType"}, + "format": {"$ref": "#/definitions/VkFormat"}, + "components": {"$ref": "#/definitions/VkComponentMapping"}, + "subresourceRange": {"$ref": "#/definitions/VkImageSubresourceRange"} + } + }, + + "VkPipelineCacheCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkPipelineCacheCreateFlags"}, + "initialDataSize": {"$ref": "#/definitions/size_t"}, + "pInitialData": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/void"}}]} + } + }, + + "VkSpecializationMapEntry": { + "type": "object", + "additionalProperties": false, + "properties": { + "constantID": {"$ref": "#/definitions/uint32_t"}, + "offset": {"$ref": "#/definitions/uint32_t"}, + "size": {"$ref": "#/definitions/size_t"} + } + }, + + "VkSpecializationInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "mapEntryCount": {"$ref": "#/definitions/uint32_t"}, + "pMapEntries": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkSpecializationMapEntry"}}]}, + "dataSize": {"$ref": "#/definitions/size_t"}, + "pData": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/void"}}]} + } + }, + + "VkPipelineShaderStageCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkPipelineShaderStageCreateFlags"}, + "stage": {"$ref": "#/definitions/VkShaderStageFlagBits"}, + "module": {"$ref": "#/definitions/VkShaderModule"}, + "pName": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/char"}]}, + "pSpecializationInfo": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/VkSpecializationInfo"}]} + } + }, + + "VkComputePipelineCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkPipelineCreateFlags"}, + "stage": {"$ref": "#/definitions/VkPipelineShaderStageCreateInfo"}, + "layout": {"$ref": "#/definitions/VkPipelineLayout"}, + "basePipelineHandle": {"$ref": "#/definitions/VkPipeline"}, + "basePipelineIndex": {"$ref": "#/definitions/int32_t"} + } + }, + + "VkVertexInputBindingDescription": { + "type": "object", + "additionalProperties": false, + "properties": { + "binding": {"$ref": "#/definitions/uint32_t"}, + "stride": {"$ref": "#/definitions/uint32_t"}, + "inputRate": {"$ref": "#/definitions/VkVertexInputRate"} + } + }, + + "VkVertexInputAttributeDescription": { + "type": "object", + "additionalProperties": false, + "properties": { + "location": {"$ref": "#/definitions/uint32_t"}, + "binding": {"$ref": "#/definitions/uint32_t"}, + "format": {"$ref": "#/definitions/VkFormat"}, + "offset": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkPipelineVertexInputStateCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkPipelineVertexInputStateCreateFlags"}, + "vertexBindingDescriptionCount": {"$ref": "#/definitions/uint32_t"}, + "pVertexBindingDescriptions": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkVertexInputBindingDescription"}}]}, + "vertexAttributeDescriptionCount": {"$ref": "#/definitions/uint32_t"}, + "pVertexAttributeDescriptions": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkVertexInputAttributeDescription"}}]} + } + }, + + "VkPipelineInputAssemblyStateCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkPipelineInputAssemblyStateCreateFlags"}, + "topology": {"$ref": "#/definitions/VkPrimitiveTopology"}, + "primitiveRestartEnable": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPipelineTessellationStateCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkPipelineTessellationStateCreateFlags"}, + "patchControlPoints": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkViewport": { + "type": "object", + "additionalProperties": false, + "properties": { + "x": {"$ref": "#/definitions/float"}, + "y": {"$ref": "#/definitions/float"}, + "width": {"$ref": "#/definitions/float"}, + "height": {"$ref": "#/definitions/float"}, + "minDepth": {"$ref": "#/definitions/float"}, + "maxDepth": {"$ref": "#/definitions/float"} + } + }, + + "VkPipelineViewportStateCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkPipelineViewportStateCreateFlags"}, + "viewportCount": {"$ref": "#/definitions/uint32_t"}, + "pViewports": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkViewport"}}]}, + "scissorCount": {"$ref": "#/definitions/uint32_t"}, + "pScissors": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkRect2D"}}]} + } + }, + + "VkPipelineRasterizationStateCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkPipelineRasterizationStateCreateFlags"}, + "depthClampEnable": {"$ref": "#/definitions/VkBool32"}, + "rasterizerDiscardEnable": {"$ref": "#/definitions/VkBool32"}, + "polygonMode": {"$ref": "#/definitions/VkPolygonMode"}, + "cullMode": {"$ref": "#/definitions/VkCullModeFlags"}, + "frontFace": {"$ref": "#/definitions/VkFrontFace"}, + "depthBiasEnable": {"$ref": "#/definitions/VkBool32"}, + "depthBiasConstantFactor": {"$ref": "#/definitions/float"}, + "depthBiasClamp": {"$ref": "#/definitions/float"}, + "depthBiasSlopeFactor": {"$ref": "#/definitions/float"}, + "lineWidth": {"$ref": "#/definitions/float"} + } + }, + + "VkPipelineMultisampleStateCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkPipelineMultisampleStateCreateFlags"}, + "rasterizationSamples": {"$ref": "#/definitions/VkSampleCountFlagBits"}, + "sampleShadingEnable": {"$ref": "#/definitions/VkBool32"}, + "minSampleShading": {"$ref": "#/definitions/float"}, + "pSampleMask": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkSampleMask"}}]}, + "alphaToCoverageEnable": {"$ref": "#/definitions/VkBool32"}, + "alphaToOneEnable": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkStencilOpState": { + "type": "object", + "additionalProperties": false, + "properties": { + "failOp": {"$ref": "#/definitions/VkStencilOp"}, + "passOp": {"$ref": "#/definitions/VkStencilOp"}, + "depthFailOp": {"$ref": "#/definitions/VkStencilOp"}, + "compareOp": {"$ref": "#/definitions/VkCompareOp"}, + "compareMask": {"$ref": "#/definitions/uint32_t"}, + "writeMask": {"$ref": "#/definitions/uint32_t"}, + "reference": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkPipelineDepthStencilStateCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkPipelineDepthStencilStateCreateFlags"}, + "depthTestEnable": {"$ref": "#/definitions/VkBool32"}, + "depthWriteEnable": {"$ref": "#/definitions/VkBool32"}, + "depthCompareOp": {"$ref": "#/definitions/VkCompareOp"}, + "depthBoundsTestEnable": {"$ref": "#/definitions/VkBool32"}, + "stencilTestEnable": {"$ref": "#/definitions/VkBool32"}, + "front": {"$ref": "#/definitions/VkStencilOpState"}, + "back": {"$ref": "#/definitions/VkStencilOpState"}, + "minDepthBounds": {"$ref": "#/definitions/float"}, + "maxDepthBounds": {"$ref": "#/definitions/float"} + } + }, + + "VkPipelineColorBlendAttachmentState": { + "type": "object", + "additionalProperties": false, + "properties": { + "blendEnable": {"$ref": "#/definitions/VkBool32"}, + "srcColorBlendFactor": {"$ref": "#/definitions/VkBlendFactor"}, + "dstColorBlendFactor": {"$ref": "#/definitions/VkBlendFactor"}, + "colorBlendOp": {"$ref": "#/definitions/VkBlendOp"}, + "srcAlphaBlendFactor": {"$ref": "#/definitions/VkBlendFactor"}, + "dstAlphaBlendFactor": {"$ref": "#/definitions/VkBlendFactor"}, + "alphaBlendOp": {"$ref": "#/definitions/VkBlendOp"}, + "colorWriteMask": {"$ref": "#/definitions/VkColorComponentFlags"} + } + }, + + "VkPipelineColorBlendStateCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkPipelineColorBlendStateCreateFlags"}, + "logicOpEnable": {"$ref": "#/definitions/VkBool32"}, + "logicOp": {"$ref": "#/definitions/VkLogicOp"}, + "attachmentCount": {"$ref": "#/definitions/uint32_t"}, + "pAttachments": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkPipelineColorBlendAttachmentState"}}]}, + "blendConstants": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/float"}} + } + }, + + "VkPipelineDynamicStateCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkPipelineDynamicStateCreateFlags"}, + "dynamicStateCount": {"$ref": "#/definitions/uint32_t"}, + "pDynamicStates": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkDynamicState"}}]} + } + }, + + "VkGraphicsPipelineCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkPipelineCreateFlags"}, + "stageCount": {"$ref": "#/definitions/uint32_t"}, + "pStages": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkPipelineShaderStageCreateInfo"}}]}, + "pVertexInputState": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/VkPipelineVertexInputStateCreateInfo"}]}, + "pInputAssemblyState": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/VkPipelineInputAssemblyStateCreateInfo"}]}, + "pTessellationState": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/VkPipelineTessellationStateCreateInfo"}]}, + "pViewportState": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/VkPipelineViewportStateCreateInfo"}]}, + "pRasterizationState": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/VkPipelineRasterizationStateCreateInfo"}]}, + "pMultisampleState": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/VkPipelineMultisampleStateCreateInfo"}]}, + "pDepthStencilState": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/VkPipelineDepthStencilStateCreateInfo"}]}, + "pColorBlendState": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/VkPipelineColorBlendStateCreateInfo"}]}, + "pDynamicState": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/VkPipelineDynamicStateCreateInfo"}]}, + "layout": {"$ref": "#/definitions/VkPipelineLayout"}, + "renderPass": {"$ref": "#/definitions/VkRenderPass"}, + "subpass": {"$ref": "#/definitions/uint32_t"}, + "basePipelineHandle": {"$ref": "#/definitions/VkPipeline"}, + "basePipelineIndex": {"$ref": "#/definitions/int32_t"} + } + }, + + "VkPushConstantRange": { + "type": "object", + "additionalProperties": false, + "properties": { + "stageFlags": {"$ref": "#/definitions/VkShaderStageFlags"}, + "offset": {"$ref": "#/definitions/uint32_t"}, + "size": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkPipelineLayoutCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkPipelineLayoutCreateFlags"}, + "setLayoutCount": {"$ref": "#/definitions/uint32_t"}, + "pSetLayouts": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/char"}}]}, + "pushConstantRangeCount": {"$ref": "#/definitions/uint32_t"}, + "pPushConstantRanges": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkPushConstantRange"}}]} + } + }, + + "VkSamplerCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkSamplerCreateFlags"}, + "magFilter": {"$ref": "#/definitions/VkFilter"}, + "minFilter": {"$ref": "#/definitions/VkFilter"}, + "mipmapMode": {"$ref": "#/definitions/VkSamplerMipmapMode"}, + "addressModeU": {"$ref": "#/definitions/VkSamplerAddressMode"}, + "addressModeV": {"$ref": "#/definitions/VkSamplerAddressMode"}, + "addressModeW": {"$ref": "#/definitions/VkSamplerAddressMode"}, + "mipLodBias": {"$ref": "#/definitions/float"}, + "anisotropyEnable": {"$ref": "#/definitions/VkBool32"}, + "maxAnisotropy": {"$ref": "#/definitions/float"}, + "compareEnable": {"$ref": "#/definitions/VkBool32"}, + "compareOp": {"$ref": "#/definitions/VkCompareOp"}, + "minLod": {"$ref": "#/definitions/float"}, + "maxLod": {"$ref": "#/definitions/float"}, + "borderColor": {"$ref": "#/definitions/VkBorderColor"}, + "unnormalizedCoordinates": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkCopyDescriptorSet": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "srcSet": {"$ref": "#/definitions/VkDescriptorSet"}, + "srcBinding": {"$ref": "#/definitions/uint32_t"}, + "srcArrayElement": {"$ref": "#/definitions/uint32_t"}, + "dstSet": {"$ref": "#/definitions/VkDescriptorSet"}, + "dstBinding": {"$ref": "#/definitions/uint32_t"}, + "dstArrayElement": {"$ref": "#/definitions/uint32_t"}, + "descriptorCount": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkDescriptorBufferInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "buffer": {"$ref": "#/definitions/VkBuffer"}, + "offset": {"$ref": "#/definitions/VkDeviceSize"}, + "range": {"$ref": "#/definitions/VkDeviceSize"} + } + }, + + "VkDescriptorImageInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sampler": {"$ref": "#/definitions/VkSampler"}, + "imageView": {"$ref": "#/definitions/VkImageView"}, + "imageLayout": {"$ref": "#/definitions/VkImageLayout"} + } + }, + + "VkDescriptorPoolSize": { + "type": "object", + "additionalProperties": false, + "properties": { + "type": {"$ref": "#/definitions/VkDescriptorType"}, + "descriptorCount": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkDescriptorPoolCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkDescriptorPoolCreateFlags"}, + "maxSets": {"$ref": "#/definitions/uint32_t"}, + "poolSizeCount": {"$ref": "#/definitions/uint32_t"}, + "pPoolSizes": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkDescriptorPoolSize"}}]} + } + }, + + "VkDescriptorSetAllocateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "descriptorPool": {"$ref": "#/definitions/VkDescriptorPool"}, + "descriptorSetCount": {"$ref": "#/definitions/uint32_t"}, + "pSetLayouts": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkDescriptorSetLayout"}}]} + } + }, + + "VkDescriptorSetLayoutBinding": { + "type": "object", + "additionalProperties": false, + "properties": { + "binding": {"$ref": "#/definitions/uint32_t"}, + "descriptorType": {"$ref": "#/definitions/VkDescriptorType"}, + "descriptorCount": {"$ref": "#/definitions/uint32_t"}, + "stageFlags": {"$ref": "#/definitions/VkShaderStageFlags"}, + "pImmutableSamplers": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/char"}}]} + } + }, + + "VkDescriptorSetLayoutCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkDescriptorSetLayoutCreateFlags"}, + "bindingCount": {"$ref": "#/definitions/uint32_t"}, + "pBindings": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkDescriptorSetLayoutBinding"}}]} + } + }, + + "VkWriteDescriptorSet": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "dstSet": {"$ref": "#/definitions/VkDescriptorSet"}, + "dstBinding": {"$ref": "#/definitions/uint32_t"}, + "dstArrayElement": {"$ref": "#/definitions/uint32_t"}, + "descriptorCount": {"$ref": "#/definitions/uint32_t"}, + "descriptorType": {"$ref": "#/definitions/VkDescriptorType"}, + "pImageInfo": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkDescriptorImageInfo"}}]}, + "pBufferInfo": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkDescriptorBufferInfo"}}]}, + "pTexelBufferView": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkBufferView"}}]} + } + }, + + "VkAttachmentDescription": { + "type": "object", + "additionalProperties": false, + "properties": { + "flags": {"$ref": "#/definitions/VkAttachmentDescriptionFlags"}, + "format": {"$ref": "#/definitions/VkFormat"}, + "samples": {"$ref": "#/definitions/VkSampleCountFlagBits"}, + "loadOp": {"$ref": "#/definitions/VkAttachmentLoadOp"}, + "storeOp": {"$ref": "#/definitions/VkAttachmentStoreOp"}, + "stencilLoadOp": {"$ref": "#/definitions/VkAttachmentLoadOp"}, + "stencilStoreOp": {"$ref": "#/definitions/VkAttachmentStoreOp"}, + "initialLayout": {"$ref": "#/definitions/VkImageLayout"}, + "finalLayout": {"$ref": "#/definitions/VkImageLayout"} + } + }, + + "VkAttachmentReference": { + "type": "object", + "additionalProperties": false, + "properties": { + "attachment": {"$ref": "#/definitions/uint32_t"}, + "layout": {"$ref": "#/definitions/VkImageLayout"} + } + }, + + "VkFramebufferCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkFramebufferCreateFlags"}, + "renderPass": {"$ref": "#/definitions/VkRenderPass"}, + "attachmentCount": {"$ref": "#/definitions/uint32_t"}, + "pAttachments": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkImageView"}}]}, + "width": {"$ref": "#/definitions/uint32_t"}, + "height": {"$ref": "#/definitions/uint32_t"}, + "layers": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkSubpassDescription": { + "type": "object", + "additionalProperties": false, + "properties": { + "flags": {"$ref": "#/definitions/VkSubpassDescriptionFlags"}, + "pipelineBindPoint": {"$ref": "#/definitions/VkPipelineBindPoint"}, + "inputAttachmentCount": {"$ref": "#/definitions/uint32_t"}, + "pInputAttachments": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkAttachmentReference"}}]}, + "colorAttachmentCount": {"$ref": "#/definitions/uint32_t"}, + "pColorAttachments": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkAttachmentReference"}}]}, + "pResolveAttachments": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkAttachmentReference"}}]}, + "pDepthStencilAttachment": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/VkAttachmentReference"}]}, + "preserveAttachmentCount": {"$ref": "#/definitions/uint32_t"}, + "pPreserveAttachments": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}}]} + } + }, + + "VkSubpassDependency": { + "type": "object", + "additionalProperties": false, + "properties": { + "srcSubpass": {"$ref": "#/definitions/uint32_t"}, + "dstSubpass": {"$ref": "#/definitions/uint32_t"}, + "srcStageMask": {"$ref": "#/definitions/VkPipelineStageFlags"}, + "dstStageMask": {"$ref": "#/definitions/VkPipelineStageFlags"}, + "srcAccessMask": {"$ref": "#/definitions/VkAccessFlags"}, + "dstAccessMask": {"$ref": "#/definitions/VkAccessFlags"}, + "dependencyFlags": {"$ref": "#/definitions/VkDependencyFlags"} + } + }, + + "VkRenderPassCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkRenderPassCreateFlags"}, + "attachmentCount": {"$ref": "#/definitions/uint32_t"}, + "pAttachments": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkAttachmentDescription"}}]}, + "subpassCount": {"$ref": "#/definitions/uint32_t"}, + "pSubpasses": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkSubpassDescription"}}]}, + "dependencyCount": {"$ref": "#/definitions/uint32_t"}, + "pDependencies": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkSubpassDependency"}}]} + } + }, + + "VkCommandPoolCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkCommandPoolCreateFlags"}, + "queueFamilyIndex": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkCommandBufferAllocateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "commandPool": {"$ref": "#/definitions/VkCommandPool"}, + "level": {"$ref": "#/definitions/VkCommandBufferLevel"}, + "commandBufferCount": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkCommandBufferInheritanceInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "renderPass": {"$ref": "#/definitions/VkRenderPass"}, + "subpass": {"$ref": "#/definitions/uint32_t"}, + "framebuffer": {"$ref": "#/definitions/VkFramebuffer"}, + "occlusionQueryEnable": {"$ref": "#/definitions/VkBool32"}, + "queryFlags": {"$ref": "#/definitions/VkQueryControlFlags"}, + "pipelineStatistics": {"$ref": "#/definitions/VkQueryPipelineStatisticFlags"} + } + }, + + "VkCommandBufferBeginInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkCommandBufferUsageFlags"}, + "pInheritanceInfo": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/VkCommandBufferInheritanceInfo"}]} + } + }, + + "VkBufferCopy": { + "type": "object", + "additionalProperties": false, + "properties": { + "srcOffset": {"$ref": "#/definitions/VkDeviceSize"}, + "dstOffset": {"$ref": "#/definitions/VkDeviceSize"}, + "size": {"$ref": "#/definitions/VkDeviceSize"} + } + }, + + "VkImageSubresourceLayers": { + "type": "object", + "additionalProperties": false, + "properties": { + "aspectMask": {"$ref": "#/definitions/VkImageAspectFlags"}, + "mipLevel": {"$ref": "#/definitions/uint32_t"}, + "baseArrayLayer": {"$ref": "#/definitions/uint32_t"}, + "layerCount": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkBufferImageCopy": { + "type": "object", + "additionalProperties": false, + "properties": { + "bufferOffset": {"$ref": "#/definitions/VkDeviceSize"}, + "bufferRowLength": {"$ref": "#/definitions/uint32_t"}, + "bufferImageHeight": {"$ref": "#/definitions/uint32_t"}, + "imageSubresource": {"$ref": "#/definitions/VkImageSubresourceLayers"}, + "imageOffset": {"$ref": "#/definitions/VkOffset3D"}, + "imageExtent": {"$ref": "#/definitions/VkExtent3D"} + } + }, + + "VkClearColorValue": { + "type": "object", + "additionalProperties": false, + "properties": { + "float32": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/float"}}, + "int32": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/int32_t"}}, + "uint32": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}} + } + }, + + "VkClearDepthStencilValue": { + "type": "object", + "additionalProperties": false, + "properties": { + "depth": {"$ref": "#/definitions/float"}, + "stencil": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkClearValue": { + "type": "object", + "additionalProperties": false, + "properties": { + "color": {"$ref": "#/definitions/VkClearColorValue"}, + "depthStencil": {"$ref": "#/definitions/VkClearDepthStencilValue"} + } + }, + + "VkClearAttachment": { + "type": "object", + "additionalProperties": false, + "properties": { + "aspectMask": {"$ref": "#/definitions/VkImageAspectFlags"}, + "colorAttachment": {"$ref": "#/definitions/uint32_t"}, + "clearValue": {"$ref": "#/definitions/VkClearValue"} + } + }, + + "VkClearRect": { + "type": "object", + "additionalProperties": false, + "properties": { + "rect": {"$ref": "#/definitions/VkRect2D"}, + "baseArrayLayer": {"$ref": "#/definitions/uint32_t"}, + "layerCount": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkImageBlit": { + "type": "object", + "additionalProperties": false, + "properties": { + "srcSubresource": {"$ref": "#/definitions/VkImageSubresourceLayers"}, + "srcOffsets": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkOffset3D"}}, + "dstSubresource": {"$ref": "#/definitions/VkImageSubresourceLayers"}, + "dstOffsets": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkOffset3D"}} + } + }, + + "VkImageCopy": { + "type": "object", + "additionalProperties": false, + "properties": { + "srcSubresource": {"$ref": "#/definitions/VkImageSubresourceLayers"}, + "srcOffset": {"$ref": "#/definitions/VkOffset3D"}, + "dstSubresource": {"$ref": "#/definitions/VkImageSubresourceLayers"}, + "dstOffset": {"$ref": "#/definitions/VkOffset3D"}, + "extent": {"$ref": "#/definitions/VkExtent3D"} + } + }, + + "VkImageResolve": { + "type": "object", + "additionalProperties": false, + "properties": { + "srcSubresource": {"$ref": "#/definitions/VkImageSubresourceLayers"}, + "srcOffset": {"$ref": "#/definitions/VkOffset3D"}, + "dstSubresource": {"$ref": "#/definitions/VkImageSubresourceLayers"}, + "dstOffset": {"$ref": "#/definitions/VkOffset3D"}, + "extent": {"$ref": "#/definitions/VkExtent3D"} + } + }, + + "VkRenderPassBeginInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "renderPass": {"$ref": "#/definitions/VkRenderPass"}, + "framebuffer": {"$ref": "#/definitions/VkFramebuffer"}, + "renderArea": {"$ref": "#/definitions/VkRect2D"}, + "clearValueCount": {"$ref": "#/definitions/uint32_t"}, + "pClearValues": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkClearValue"}}]} + } + }, + + "VkSamplerYcbcrConversion": {"$ref": "#/definitions/uint64_t"}, + "VkSubgroupFeatureFlagBits": {"$ref": "#/definitions/enum"}, + "VkPeerMemoryFeatureFlagBits": {"$ref": "#/definitions/enum"}, + "VkMemoryAllocateFlagBits": {"$ref": "#/definitions/enum"}, + "VkPointClippingBehavior": {"$ref": "#/definitions/enum"}, + "VkTessellationDomainOrigin": {"$ref": "#/definitions/enum"}, + "VkSamplerYcbcrModelConversion": {"$ref": "#/definitions/enum"}, + "VkSamplerYcbcrRange": {"$ref": "#/definitions/enum"}, + "VkChromaLocation": {"$ref": "#/definitions/enum"}, + "VkExternalMemoryHandleTypeFlagBits": {"$ref": "#/definitions/enum"}, + "VkExternalMemoryFeatureFlagBits": {"$ref": "#/definitions/enum"}, + "VkExternalFenceHandleTypeFlagBits": {"$ref": "#/definitions/enum"}, + "VkExternalFenceFeatureFlagBits": {"$ref": "#/definitions/enum"}, + "VkFenceImportFlagBits": {"$ref": "#/definitions/enum"}, + "VkSemaphoreImportFlagBits": {"$ref": "#/definitions/enum"}, + "VkExternalSemaphoreHandleTypeFlagBits": {"$ref": "#/definitions/enum"}, + "VkExternalSemaphoreFeatureFlagBits": {"$ref": "#/definitions/enum"}, + "VkSubgroupFeatureFlags": {"$ref": "#/definitions/VkFlags"}, + "VkPeerMemoryFeatureFlags": {"$ref": "#/definitions/VkFlags"}, + "VkMemoryAllocateFlags": {"$ref": "#/definitions/VkFlags"}, + "VkExternalMemoryHandleTypeFlags": {"$ref": "#/definitions/VkFlags"}, + "VkExternalMemoryFeatureFlags": {"$ref": "#/definitions/VkFlags"}, + "VkExternalFenceHandleTypeFlags": {"$ref": "#/definitions/VkFlags"}, + "VkExternalFenceFeatureFlags": {"$ref": "#/definitions/VkFlags"}, + "VkFenceImportFlags": {"$ref": "#/definitions/VkFlags"}, + "VkSemaphoreImportFlags": {"$ref": "#/definitions/VkFlags"}, + "VkExternalSemaphoreHandleTypeFlags": {"$ref": "#/definitions/VkFlags"}, + "VkExternalSemaphoreFeatureFlags": {"$ref": "#/definitions/VkFlags"}, + "VkPhysicalDeviceSubgroupProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "subgroupSize": {"$ref": "#/definitions/uint32_t"}, + "supportedStages": {"$ref": "#/definitions/VkShaderStageFlags"}, + "supportedOperations": {"$ref": "#/definitions/VkSubgroupFeatureFlags"}, + "quadOperationsInAllStages": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkBindBufferMemoryInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "buffer": {"$ref": "#/definitions/VkBuffer"}, + "memory": {"$ref": "#/definitions/VkDeviceMemory"}, + "memoryOffset": {"$ref": "#/definitions/VkDeviceSize"} + } + }, + + "VkBindImageMemoryInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "image": {"$ref": "#/definitions/VkImage"}, + "memory": {"$ref": "#/definitions/VkDeviceMemory"}, + "memoryOffset": {"$ref": "#/definitions/VkDeviceSize"} + } + }, + + "VkPhysicalDevice16BitStorageFeatures": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "storageBuffer16BitAccess": {"$ref": "#/definitions/VkBool32"}, + "uniformAndStorageBuffer16BitAccess": {"$ref": "#/definitions/VkBool32"}, + "storagePushConstant16": {"$ref": "#/definitions/VkBool32"}, + "storageInputOutput16": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkMemoryDedicatedRequirements": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "prefersDedicatedAllocation": {"$ref": "#/definitions/VkBool32"}, + "requiresDedicatedAllocation": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkMemoryDedicatedAllocateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "image": {"$ref": "#/definitions/VkImage"}, + "buffer": {"$ref": "#/definitions/VkBuffer"} + } + }, + + "VkMemoryAllocateFlagsInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkMemoryAllocateFlags"}, + "deviceMask": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkDeviceGroupRenderPassBeginInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "deviceMask": {"$ref": "#/definitions/uint32_t"}, + "deviceRenderAreaCount": {"$ref": "#/definitions/uint32_t"}, + "pDeviceRenderAreas": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkRect2D"}}]} + } + }, + + "VkDeviceGroupCommandBufferBeginInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "deviceMask": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkDeviceGroupSubmitInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "waitSemaphoreCount": {"$ref": "#/definitions/uint32_t"}, + "pWaitSemaphoreDeviceIndices": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}}]}, + "commandBufferCount": {"$ref": "#/definitions/uint32_t"}, + "pCommandBufferDeviceMasks": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}}]}, + "signalSemaphoreCount": {"$ref": "#/definitions/uint32_t"}, + "pSignalSemaphoreDeviceIndices": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}}]} + } + }, + + "VkBindBufferMemoryDeviceGroupInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "deviceIndexCount": {"$ref": "#/definitions/uint32_t"}, + "pDeviceIndices": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}}]} + } + }, + + "VkBindImageMemoryDeviceGroupInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "deviceIndexCount": {"$ref": "#/definitions/uint32_t"}, + "pDeviceIndices": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}}]}, + "splitInstanceBindRegionCount": {"$ref": "#/definitions/uint32_t"}, + "pSplitInstanceBindRegions": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkRect2D"}}]} + } + }, + + "VkPhysicalDeviceGroupProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "physicalDeviceCount": {"$ref": "#/definitions/uint32_t"}, + "physicalDevices": {"$ref": "#/definitions/VkPhysicalDevice"}, + "subsetAllocation": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkDeviceGroupDeviceCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "physicalDeviceCount": {"$ref": "#/definitions/uint32_t"}, + "pPhysicalDevices": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkPhysicalDevice"}}]} + } + }, + + "VkBufferMemoryRequirementsInfo2": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "buffer": {"$ref": "#/definitions/VkBuffer"} + } + }, + + "VkImageMemoryRequirementsInfo2": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "image": {"$ref": "#/definitions/VkImage"} + } + }, + + "VkMemoryRequirements2": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "memoryRequirements": {"$ref": "#/definitions/VkMemoryRequirements"} + } + }, + + "VkPhysicalDeviceFeatures2": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "features": {"$ref": "#/definitions/VkPhysicalDeviceFeatures"} + } + }, + + "VkPhysicalDeviceProperties2": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "properties": {"$ref": "#/definitions/VkPhysicalDeviceProperties"} + } + }, + + "VkFormatProperties2": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "formatProperties": {"$ref": "#/definitions/VkFormatProperties"} + } + }, + + "VkImageFormatProperties2": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "imageFormatProperties": {"$ref": "#/definitions/VkImageFormatProperties"} + } + }, + + "VkPhysicalDeviceImageFormatInfo2": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "format": {"$ref": "#/definitions/VkFormat"}, + "type": {"$ref": "#/definitions/VkImageType"}, + "tiling": {"$ref": "#/definitions/VkImageTiling"}, + "usage": {"$ref": "#/definitions/VkImageUsageFlags"}, + "flags": {"$ref": "#/definitions/VkImageCreateFlags"} + } + }, + + "VkQueueFamilyProperties2": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "queueFamilyProperties": {"$ref": "#/definitions/VkQueueFamilyProperties"} + } + }, + + "VkPhysicalDeviceMemoryProperties2": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "memoryProperties": {"$ref": "#/definitions/VkPhysicalDeviceMemoryProperties"} + } + }, + + "VkPhysicalDevicePointClippingProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "pointClippingBehavior": {"$ref": "#/definitions/VkPointClippingBehavior"} + } + }, + + "VkInputAttachmentAspectReference": { + "type": "object", + "additionalProperties": false, + "properties": { + "subpass": {"$ref": "#/definitions/uint32_t"}, + "inputAttachmentIndex": {"$ref": "#/definitions/uint32_t"}, + "aspectMask": {"$ref": "#/definitions/VkImageAspectFlags"} + } + }, + + "VkRenderPassInputAttachmentAspectCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "aspectReferenceCount": {"$ref": "#/definitions/uint32_t"}, + "pAspectReferences": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkInputAttachmentAspectReference"}}]} + } + }, + + "VkImageViewUsageCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "usage": {"$ref": "#/definitions/VkImageUsageFlags"} + } + }, + + "VkPipelineTessellationDomainOriginStateCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "domainOrigin": {"$ref": "#/definitions/VkTessellationDomainOrigin"} + } + }, + + "VkRenderPassMultiviewCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "subpassCount": {"$ref": "#/definitions/uint32_t"}, + "pViewMasks": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}}]}, + "dependencyCount": {"$ref": "#/definitions/uint32_t"}, + "pViewOffsets": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/int32_t"}}]}, + "correlationMaskCount": {"$ref": "#/definitions/uint32_t"}, + "pCorrelationMasks": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}}]} + } + }, + + "VkPhysicalDeviceMultiviewFeatures": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "multiview": {"$ref": "#/definitions/VkBool32"}, + "multiviewGeometryShader": {"$ref": "#/definitions/VkBool32"}, + "multiviewTessellationShader": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceMultiviewProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "maxMultiviewViewCount": {"$ref": "#/definitions/uint32_t"}, + "maxMultiviewInstanceIndex": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkPhysicalDeviceVariablePointersFeatures": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "variablePointersStorageBuffer": {"$ref": "#/definitions/VkBool32"}, + "variablePointers": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceProtectedMemoryFeatures": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "protectedMemory": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceProtectedMemoryProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "protectedNoFault": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkDeviceQueueInfo2": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkDeviceQueueCreateFlags"}, + "queueFamilyIndex": {"$ref": "#/definitions/uint32_t"}, + "queueIndex": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkProtectedSubmitInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "protectedSubmit": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkSamplerYcbcrConversionCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "format": {"$ref": "#/definitions/VkFormat"}, + "ycbcrModel": {"$ref": "#/definitions/VkSamplerYcbcrModelConversion"}, + "ycbcrRange": {"$ref": "#/definitions/VkSamplerYcbcrRange"}, + "components": {"$ref": "#/definitions/VkComponentMapping"}, + "xChromaOffset": {"$ref": "#/definitions/VkChromaLocation"}, + "yChromaOffset": {"$ref": "#/definitions/VkChromaLocation"}, + "chromaFilter": {"$ref": "#/definitions/VkFilter"}, + "forceExplicitReconstruction": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkSamplerYcbcrConversionInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "conversion": {"$ref": "#/definitions/VkSamplerYcbcrConversion"} + } + }, + + "VkBindImagePlaneMemoryInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "planeAspect": {"$ref": "#/definitions/VkImageAspectFlagBits"} + } + }, + + "VkImagePlaneMemoryRequirementsInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "planeAspect": {"$ref": "#/definitions/VkImageAspectFlagBits"} + } + }, + + "VkPhysicalDeviceSamplerYcbcrConversionFeatures": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "samplerYcbcrConversion": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkSamplerYcbcrConversionImageFormatProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "combinedImageSamplerDescriptorCount": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkExternalMemoryProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "externalMemoryFeatures": {"$ref": "#/definitions/VkExternalMemoryFeatureFlags"}, + "exportFromImportedHandleTypes": {"$ref": "#/definitions/VkExternalMemoryHandleTypeFlags"}, + "compatibleHandleTypes": {"$ref": "#/definitions/VkExternalMemoryHandleTypeFlags"} + } + }, + + "VkPhysicalDeviceExternalImageFormatInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "handleType": {"$ref": "#/definitions/VkExternalMemoryHandleTypeFlagBits"} + } + }, + + "VkExternalImageFormatProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "externalMemoryProperties": {"$ref": "#/definitions/VkExternalMemoryProperties"} + } + }, + + "VkPhysicalDeviceExternalBufferInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkBufferCreateFlags"}, + "usage": {"$ref": "#/definitions/VkBufferUsageFlags"}, + "handleType": {"$ref": "#/definitions/VkExternalMemoryHandleTypeFlagBits"} + } + }, + + "VkExternalBufferProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "externalMemoryProperties": {"$ref": "#/definitions/VkExternalMemoryProperties"} + } + }, + + "VkPhysicalDeviceIDProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "deviceUUID": {"$ref": "#/definitions/uint8_t"}, + "driverUUID": {"$ref": "#/definitions/uint8_t"}, + "deviceLUID": {"$ref": "#/definitions/uint8_t"}, + "deviceNodeMask": {"$ref": "#/definitions/uint32_t"}, + "deviceLUIDValid": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkExternalMemoryImageCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "handleTypes": {"$ref": "#/definitions/VkExternalMemoryHandleTypeFlags"} + } + }, + + "VkExternalMemoryBufferCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "handleTypes": {"$ref": "#/definitions/VkExternalMemoryHandleTypeFlags"} + } + }, + + "VkExportMemoryAllocateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "handleTypes": {"$ref": "#/definitions/VkExternalMemoryHandleTypeFlags"} + } + }, + + "VkPhysicalDeviceExternalFenceInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "handleType": {"$ref": "#/definitions/VkExternalFenceHandleTypeFlagBits"} + } + }, + + "VkExternalFenceProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "exportFromImportedHandleTypes": {"$ref": "#/definitions/VkExternalFenceHandleTypeFlags"}, + "compatibleHandleTypes": {"$ref": "#/definitions/VkExternalFenceHandleTypeFlags"}, + "externalFenceFeatures": {"$ref": "#/definitions/VkExternalFenceFeatureFlags"} + } + }, + + "VkExportFenceCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "handleTypes": {"$ref": "#/definitions/VkExternalFenceHandleTypeFlags"} + } + }, + + "VkExportSemaphoreCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "handleTypes": {"$ref": "#/definitions/VkExternalSemaphoreHandleTypeFlags"} + } + }, + + "VkPhysicalDeviceExternalSemaphoreInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "handleType": {"$ref": "#/definitions/VkExternalSemaphoreHandleTypeFlagBits"} + } + }, + + "VkExternalSemaphoreProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "exportFromImportedHandleTypes": {"$ref": "#/definitions/VkExternalSemaphoreHandleTypeFlags"}, + "compatibleHandleTypes": {"$ref": "#/definitions/VkExternalSemaphoreHandleTypeFlags"}, + "externalSemaphoreFeatures": {"$ref": "#/definitions/VkExternalSemaphoreFeatureFlags"} + } + }, + + "VkPhysicalDeviceMaintenance3Properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "maxPerSetDescriptors": {"$ref": "#/definitions/uint32_t"}, + "maxMemoryAllocationSize": {"$ref": "#/definitions/VkDeviceSize"} + } + }, + + "VkDescriptorSetLayoutSupport": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "supported": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceShaderDrawParametersFeatures": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "shaderDrawParameters": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkDriverId": {"$ref": "#/definitions/enum"}, + "VkShaderFloatControlsIndependence": {"$ref": "#/definitions/enum"}, + "VkResolveModeFlagBits": {"$ref": "#/definitions/enum"}, + "VkDescriptorBindingFlagBits": {"$ref": "#/definitions/enum"}, + "VkSamplerReductionMode": {"$ref": "#/definitions/enum"}, + "VkSemaphoreType": {"$ref": "#/definitions/enum"}, + "VkSemaphoreWaitFlagBits": {"$ref": "#/definitions/enum"}, + "VkResolveModeFlags": {"$ref": "#/definitions/VkFlags"}, + "VkDescriptorBindingFlags": {"$ref": "#/definitions/VkFlags"}, + "VkSemaphoreWaitFlags": {"$ref": "#/definitions/VkFlags"}, + "VkPhysicalDeviceVulkan11Features": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "storageBuffer16BitAccess": {"$ref": "#/definitions/VkBool32"}, + "uniformAndStorageBuffer16BitAccess": {"$ref": "#/definitions/VkBool32"}, + "storagePushConstant16": {"$ref": "#/definitions/VkBool32"}, + "storageInputOutput16": {"$ref": "#/definitions/VkBool32"}, + "multiview": {"$ref": "#/definitions/VkBool32"}, + "multiviewGeometryShader": {"$ref": "#/definitions/VkBool32"}, + "multiviewTessellationShader": {"$ref": "#/definitions/VkBool32"}, + "variablePointersStorageBuffer": {"$ref": "#/definitions/VkBool32"}, + "variablePointers": {"$ref": "#/definitions/VkBool32"}, + "protectedMemory": {"$ref": "#/definitions/VkBool32"}, + "samplerYcbcrConversion": {"$ref": "#/definitions/VkBool32"}, + "shaderDrawParameters": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceVulkan11Properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "deviceUUID": {"$ref": "#/definitions/uint8_t"}, + "driverUUID": {"$ref": "#/definitions/uint8_t"}, + "deviceLUID": {"$ref": "#/definitions/uint8_t"}, + "deviceNodeMask": {"$ref": "#/definitions/uint32_t"}, + "deviceLUIDValid": {"$ref": "#/definitions/VkBool32"}, + "subgroupSize": {"$ref": "#/definitions/uint32_t"}, + "subgroupSupportedStages": {"$ref": "#/definitions/VkShaderStageFlags"}, + "subgroupSupportedOperations": {"$ref": "#/definitions/VkSubgroupFeatureFlags"}, + "subgroupQuadOperationsInAllStages": {"$ref": "#/definitions/VkBool32"}, + "pointClippingBehavior": {"$ref": "#/definitions/VkPointClippingBehavior"}, + "maxMultiviewViewCount": {"$ref": "#/definitions/uint32_t"}, + "maxMultiviewInstanceIndex": {"$ref": "#/definitions/uint32_t"}, + "protectedNoFault": {"$ref": "#/definitions/VkBool32"}, + "maxPerSetDescriptors": {"$ref": "#/definitions/uint32_t"}, + "maxMemoryAllocationSize": {"$ref": "#/definitions/VkDeviceSize"} + } + }, + + "VkPhysicalDeviceVulkan12Features": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "samplerMirrorClampToEdge": {"$ref": "#/definitions/VkBool32"}, + "drawIndirectCount": {"$ref": "#/definitions/VkBool32"}, + "storageBuffer8BitAccess": {"$ref": "#/definitions/VkBool32"}, + "uniformAndStorageBuffer8BitAccess": {"$ref": "#/definitions/VkBool32"}, + "storagePushConstant8": {"$ref": "#/definitions/VkBool32"}, + "shaderBufferInt64Atomics": {"$ref": "#/definitions/VkBool32"}, + "shaderSharedInt64Atomics": {"$ref": "#/definitions/VkBool32"}, + "shaderFloat16": {"$ref": "#/definitions/VkBool32"}, + "shaderInt8": {"$ref": "#/definitions/VkBool32"}, + "descriptorIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderInputAttachmentArrayDynamicIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderUniformTexelBufferArrayDynamicIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderStorageTexelBufferArrayDynamicIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderUniformBufferArrayNonUniformIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderSampledImageArrayNonUniformIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderStorageBufferArrayNonUniformIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderStorageImageArrayNonUniformIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderInputAttachmentArrayNonUniformIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderUniformTexelBufferArrayNonUniformIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderStorageTexelBufferArrayNonUniformIndexing": {"$ref": "#/definitions/VkBool32"}, + "descriptorBindingUniformBufferUpdateAfterBind": {"$ref": "#/definitions/VkBool32"}, + "descriptorBindingSampledImageUpdateAfterBind": {"$ref": "#/definitions/VkBool32"}, + "descriptorBindingStorageImageUpdateAfterBind": {"$ref": "#/definitions/VkBool32"}, + "descriptorBindingStorageBufferUpdateAfterBind": {"$ref": "#/definitions/VkBool32"}, + "descriptorBindingUniformTexelBufferUpdateAfterBind": {"$ref": "#/definitions/VkBool32"}, + "descriptorBindingStorageTexelBufferUpdateAfterBind": {"$ref": "#/definitions/VkBool32"}, + "descriptorBindingUpdateUnusedWhilePending": {"$ref": "#/definitions/VkBool32"}, + "descriptorBindingPartiallyBound": {"$ref": "#/definitions/VkBool32"}, + "descriptorBindingVariableDescriptorCount": {"$ref": "#/definitions/VkBool32"}, + "runtimeDescriptorArray": {"$ref": "#/definitions/VkBool32"}, + "samplerFilterMinmax": {"$ref": "#/definitions/VkBool32"}, + "scalarBlockLayout": {"$ref": "#/definitions/VkBool32"}, + "imagelessFramebuffer": {"$ref": "#/definitions/VkBool32"}, + "uniformBufferStandardLayout": {"$ref": "#/definitions/VkBool32"}, + "shaderSubgroupExtendedTypes": {"$ref": "#/definitions/VkBool32"}, + "separateDepthStencilLayouts": {"$ref": "#/definitions/VkBool32"}, + "hostQueryReset": {"$ref": "#/definitions/VkBool32"}, + "timelineSemaphore": {"$ref": "#/definitions/VkBool32"}, + "bufferDeviceAddress": {"$ref": "#/definitions/VkBool32"}, + "bufferDeviceAddressCaptureReplay": {"$ref": "#/definitions/VkBool32"}, + "bufferDeviceAddressMultiDevice": {"$ref": "#/definitions/VkBool32"}, + "vulkanMemoryModel": {"$ref": "#/definitions/VkBool32"}, + "vulkanMemoryModelDeviceScope": {"$ref": "#/definitions/VkBool32"}, + "vulkanMemoryModelAvailabilityVisibilityChains": {"$ref": "#/definitions/VkBool32"}, + "shaderOutputViewportIndex": {"$ref": "#/definitions/VkBool32"}, + "shaderOutputLayer": {"$ref": "#/definitions/VkBool32"}, + "subgroupBroadcastDynamicId": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkConformanceVersion": { + "type": "object", + "additionalProperties": false, + "properties": { + "major": {"$ref": "#/definitions/uint8_t"}, + "minor": {"$ref": "#/definitions/uint8_t"}, + "subminor": {"$ref": "#/definitions/uint8_t"}, + "patch": {"$ref": "#/definitions/uint8_t"} + } + }, + + "VkPhysicalDeviceVulkan12Properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "driverID": {"$ref": "#/definitions/VkDriverId"}, + "driverName": {"$ref": "#/definitions/char"}, + "driverInfo": {"$ref": "#/definitions/char"}, + "conformanceVersion": {"$ref": "#/definitions/VkConformanceVersion"}, + "denormBehaviorIndependence": {"$ref": "#/definitions/VkShaderFloatControlsIndependence"}, + "roundingModeIndependence": {"$ref": "#/definitions/VkShaderFloatControlsIndependence"}, + "shaderSignedZeroInfNanPreserveFloat16": {"$ref": "#/definitions/VkBool32"}, + "shaderSignedZeroInfNanPreserveFloat32": {"$ref": "#/definitions/VkBool32"}, + "shaderSignedZeroInfNanPreserveFloat64": {"$ref": "#/definitions/VkBool32"}, + "shaderDenormPreserveFloat16": {"$ref": "#/definitions/VkBool32"}, + "shaderDenormPreserveFloat32": {"$ref": "#/definitions/VkBool32"}, + "shaderDenormPreserveFloat64": {"$ref": "#/definitions/VkBool32"}, + "shaderDenormFlushToZeroFloat16": {"$ref": "#/definitions/VkBool32"}, + "shaderDenormFlushToZeroFloat32": {"$ref": "#/definitions/VkBool32"}, + "shaderDenormFlushToZeroFloat64": {"$ref": "#/definitions/VkBool32"}, + "shaderRoundingModeRTEFloat16": {"$ref": "#/definitions/VkBool32"}, + "shaderRoundingModeRTEFloat32": {"$ref": "#/definitions/VkBool32"}, + "shaderRoundingModeRTEFloat64": {"$ref": "#/definitions/VkBool32"}, + "shaderRoundingModeRTZFloat16": {"$ref": "#/definitions/VkBool32"}, + "shaderRoundingModeRTZFloat32": {"$ref": "#/definitions/VkBool32"}, + "shaderRoundingModeRTZFloat64": {"$ref": "#/definitions/VkBool32"}, + "maxUpdateAfterBindDescriptorsInAllPools": {"$ref": "#/definitions/uint32_t"}, + "shaderUniformBufferArrayNonUniformIndexingNative": {"$ref": "#/definitions/VkBool32"}, + "shaderSampledImageArrayNonUniformIndexingNative": {"$ref": "#/definitions/VkBool32"}, + "shaderStorageBufferArrayNonUniformIndexingNative": {"$ref": "#/definitions/VkBool32"}, + "shaderStorageImageArrayNonUniformIndexingNative": {"$ref": "#/definitions/VkBool32"}, + "shaderInputAttachmentArrayNonUniformIndexingNative": {"$ref": "#/definitions/VkBool32"}, + "robustBufferAccessUpdateAfterBind": {"$ref": "#/definitions/VkBool32"}, + "quadDivergentImplicitLod": {"$ref": "#/definitions/VkBool32"}, + "maxPerStageDescriptorUpdateAfterBindSamplers": {"$ref": "#/definitions/uint32_t"}, + "maxPerStageDescriptorUpdateAfterBindUniformBuffers": {"$ref": "#/definitions/uint32_t"}, + "maxPerStageDescriptorUpdateAfterBindStorageBuffers": {"$ref": "#/definitions/uint32_t"}, + "maxPerStageDescriptorUpdateAfterBindSampledImages": {"$ref": "#/definitions/uint32_t"}, + "maxPerStageDescriptorUpdateAfterBindStorageImages": {"$ref": "#/definitions/uint32_t"}, + "maxPerStageDescriptorUpdateAfterBindInputAttachments": {"$ref": "#/definitions/uint32_t"}, + "maxPerStageUpdateAfterBindResources": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetUpdateAfterBindSamplers": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetUpdateAfterBindUniformBuffers": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetUpdateAfterBindStorageBuffers": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetUpdateAfterBindSampledImages": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetUpdateAfterBindStorageImages": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetUpdateAfterBindInputAttachments": {"$ref": "#/definitions/uint32_t"}, + "supportedDepthResolveModes": {"$ref": "#/definitions/VkResolveModeFlags"}, + "supportedStencilResolveModes": {"$ref": "#/definitions/VkResolveModeFlags"}, + "independentResolveNone": {"$ref": "#/definitions/VkBool32"}, + "independentResolve": {"$ref": "#/definitions/VkBool32"}, + "filterMinmaxSingleComponentFormats": {"$ref": "#/definitions/VkBool32"}, + "filterMinmaxImageComponentMapping": {"$ref": "#/definitions/VkBool32"}, + "maxTimelineSemaphoreValueDifference": {"$ref": "#/definitions/uint64_t"}, + "framebufferIntegerColorSampleCounts": {"$ref": "#/definitions/VkSampleCountFlags"} + } + }, + + "VkImageFormatListCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "viewFormatCount": {"$ref": "#/definitions/uint32_t"}, + "pViewFormats": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkFormat"}}]} + } + }, + + "VkAttachmentDescription2": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkAttachmentDescriptionFlags"}, + "format": {"$ref": "#/definitions/VkFormat"}, + "samples": {"$ref": "#/definitions/VkSampleCountFlagBits"}, + "loadOp": {"$ref": "#/definitions/VkAttachmentLoadOp"}, + "storeOp": {"$ref": "#/definitions/VkAttachmentStoreOp"}, + "stencilLoadOp": {"$ref": "#/definitions/VkAttachmentLoadOp"}, + "stencilStoreOp": {"$ref": "#/definitions/VkAttachmentStoreOp"}, + "initialLayout": {"$ref": "#/definitions/VkImageLayout"}, + "finalLayout": {"$ref": "#/definitions/VkImageLayout"} + } + }, + + "VkAttachmentReference2": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "attachment": {"$ref": "#/definitions/uint32_t"}, + "layout": {"$ref": "#/definitions/VkImageLayout"}, + "aspectMask": {"$ref": "#/definitions/VkImageAspectFlags"} + } + }, + + "VkSubpassDescription2": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkSubpassDescriptionFlags"}, + "pipelineBindPoint": {"$ref": "#/definitions/VkPipelineBindPoint"}, + "viewMask": {"$ref": "#/definitions/uint32_t"}, + "inputAttachmentCount": {"$ref": "#/definitions/uint32_t"}, + "pInputAttachments": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkAttachmentReference2"}}]}, + "colorAttachmentCount": {"$ref": "#/definitions/uint32_t"}, + "pColorAttachments": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkAttachmentReference2"}}]}, + "pResolveAttachments": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkAttachmentReference2"}}]}, + "pDepthStencilAttachment": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/VkAttachmentReference2"}]}, + "preserveAttachmentCount": {"$ref": "#/definitions/uint32_t"}, + "pPreserveAttachments": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}}]} + } + }, + + "VkSubpassDependency2": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "srcSubpass": {"$ref": "#/definitions/uint32_t"}, + "dstSubpass": {"$ref": "#/definitions/uint32_t"}, + "srcStageMask": {"$ref": "#/definitions/VkPipelineStageFlags"}, + "dstStageMask": {"$ref": "#/definitions/VkPipelineStageFlags"}, + "srcAccessMask": {"$ref": "#/definitions/VkAccessFlags"}, + "dstAccessMask": {"$ref": "#/definitions/VkAccessFlags"}, + "dependencyFlags": {"$ref": "#/definitions/VkDependencyFlags"}, + "viewOffset": {"$ref": "#/definitions/int32_t"} + } + }, + + "VkRenderPassCreateInfo2": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkRenderPassCreateFlags"}, + "attachmentCount": {"$ref": "#/definitions/uint32_t"}, + "pAttachments": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkAttachmentDescription2"}}]}, + "subpassCount": {"$ref": "#/definitions/uint32_t"}, + "pSubpasses": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkSubpassDescription2"}}]}, + "dependencyCount": {"$ref": "#/definitions/uint32_t"}, + "pDependencies": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkSubpassDependency2"}}]}, + "correlatedViewMaskCount": {"$ref": "#/definitions/uint32_t"}, + "pCorrelatedViewMasks": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}}]} + } + }, + + "VkSubpassBeginInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "contents": {"$ref": "#/definitions/VkSubpassContents"} + } + }, + + "VkSubpassEndInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"} + } + }, + + "VkPhysicalDevice8BitStorageFeatures": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "storageBuffer8BitAccess": {"$ref": "#/definitions/VkBool32"}, + "uniformAndStorageBuffer8BitAccess": {"$ref": "#/definitions/VkBool32"}, + "storagePushConstant8": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceDriverProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "driverID": {"$ref": "#/definitions/VkDriverId"}, + "driverName": {"$ref": "#/definitions/char"}, + "driverInfo": {"$ref": "#/definitions/char"}, + "conformanceVersion": {"$ref": "#/definitions/VkConformanceVersion"} + } + }, + + "VkPhysicalDeviceShaderAtomicInt64Features": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "shaderBufferInt64Atomics": {"$ref": "#/definitions/VkBool32"}, + "shaderSharedInt64Atomics": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceShaderFloat16Int8Features": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "shaderFloat16": {"$ref": "#/definitions/VkBool32"}, + "shaderInt8": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceFloatControlsProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "denormBehaviorIndependence": {"$ref": "#/definitions/VkShaderFloatControlsIndependence"}, + "roundingModeIndependence": {"$ref": "#/definitions/VkShaderFloatControlsIndependence"}, + "shaderSignedZeroInfNanPreserveFloat16": {"$ref": "#/definitions/VkBool32"}, + "shaderSignedZeroInfNanPreserveFloat32": {"$ref": "#/definitions/VkBool32"}, + "shaderSignedZeroInfNanPreserveFloat64": {"$ref": "#/definitions/VkBool32"}, + "shaderDenormPreserveFloat16": {"$ref": "#/definitions/VkBool32"}, + "shaderDenormPreserveFloat32": {"$ref": "#/definitions/VkBool32"}, + "shaderDenormPreserveFloat64": {"$ref": "#/definitions/VkBool32"}, + "shaderDenormFlushToZeroFloat16": {"$ref": "#/definitions/VkBool32"}, + "shaderDenormFlushToZeroFloat32": {"$ref": "#/definitions/VkBool32"}, + "shaderDenormFlushToZeroFloat64": {"$ref": "#/definitions/VkBool32"}, + "shaderRoundingModeRTEFloat16": {"$ref": "#/definitions/VkBool32"}, + "shaderRoundingModeRTEFloat32": {"$ref": "#/definitions/VkBool32"}, + "shaderRoundingModeRTEFloat64": {"$ref": "#/definitions/VkBool32"}, + "shaderRoundingModeRTZFloat16": {"$ref": "#/definitions/VkBool32"}, + "shaderRoundingModeRTZFloat32": {"$ref": "#/definitions/VkBool32"}, + "shaderRoundingModeRTZFloat64": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkDescriptorSetLayoutBindingFlagsCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "bindingCount": {"$ref": "#/definitions/uint32_t"}, + "pBindingFlags": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkDescriptorBindingFlags"}}]} + } + }, + + "VkPhysicalDeviceDescriptorIndexingFeatures": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "shaderInputAttachmentArrayDynamicIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderUniformTexelBufferArrayDynamicIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderStorageTexelBufferArrayDynamicIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderUniformBufferArrayNonUniformIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderSampledImageArrayNonUniformIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderStorageBufferArrayNonUniformIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderStorageImageArrayNonUniformIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderInputAttachmentArrayNonUniformIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderUniformTexelBufferArrayNonUniformIndexing": {"$ref": "#/definitions/VkBool32"}, + "shaderStorageTexelBufferArrayNonUniformIndexing": {"$ref": "#/definitions/VkBool32"}, + "descriptorBindingUniformBufferUpdateAfterBind": {"$ref": "#/definitions/VkBool32"}, + "descriptorBindingSampledImageUpdateAfterBind": {"$ref": "#/definitions/VkBool32"}, + "descriptorBindingStorageImageUpdateAfterBind": {"$ref": "#/definitions/VkBool32"}, + "descriptorBindingStorageBufferUpdateAfterBind": {"$ref": "#/definitions/VkBool32"}, + "descriptorBindingUniformTexelBufferUpdateAfterBind": {"$ref": "#/definitions/VkBool32"}, + "descriptorBindingStorageTexelBufferUpdateAfterBind": {"$ref": "#/definitions/VkBool32"}, + "descriptorBindingUpdateUnusedWhilePending": {"$ref": "#/definitions/VkBool32"}, + "descriptorBindingPartiallyBound": {"$ref": "#/definitions/VkBool32"}, + "descriptorBindingVariableDescriptorCount": {"$ref": "#/definitions/VkBool32"}, + "runtimeDescriptorArray": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceDescriptorIndexingProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "maxUpdateAfterBindDescriptorsInAllPools": {"$ref": "#/definitions/uint32_t"}, + "shaderUniformBufferArrayNonUniformIndexingNative": {"$ref": "#/definitions/VkBool32"}, + "shaderSampledImageArrayNonUniformIndexingNative": {"$ref": "#/definitions/VkBool32"}, + "shaderStorageBufferArrayNonUniformIndexingNative": {"$ref": "#/definitions/VkBool32"}, + "shaderStorageImageArrayNonUniformIndexingNative": {"$ref": "#/definitions/VkBool32"}, + "shaderInputAttachmentArrayNonUniformIndexingNative": {"$ref": "#/definitions/VkBool32"}, + "robustBufferAccessUpdateAfterBind": {"$ref": "#/definitions/VkBool32"}, + "quadDivergentImplicitLod": {"$ref": "#/definitions/VkBool32"}, + "maxPerStageDescriptorUpdateAfterBindSamplers": {"$ref": "#/definitions/uint32_t"}, + "maxPerStageDescriptorUpdateAfterBindUniformBuffers": {"$ref": "#/definitions/uint32_t"}, + "maxPerStageDescriptorUpdateAfterBindStorageBuffers": {"$ref": "#/definitions/uint32_t"}, + "maxPerStageDescriptorUpdateAfterBindSampledImages": {"$ref": "#/definitions/uint32_t"}, + "maxPerStageDescriptorUpdateAfterBindStorageImages": {"$ref": "#/definitions/uint32_t"}, + "maxPerStageDescriptorUpdateAfterBindInputAttachments": {"$ref": "#/definitions/uint32_t"}, + "maxPerStageUpdateAfterBindResources": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetUpdateAfterBindSamplers": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetUpdateAfterBindUniformBuffers": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetUpdateAfterBindStorageBuffers": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetUpdateAfterBindSampledImages": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetUpdateAfterBindStorageImages": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetUpdateAfterBindInputAttachments": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkDescriptorSetVariableDescriptorCountAllocateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "descriptorSetCount": {"$ref": "#/definitions/uint32_t"}, + "pDescriptorCounts": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}}]} + } + }, + + "VkDescriptorSetVariableDescriptorCountLayoutSupport": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "maxVariableDescriptorCount": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkSubpassDescriptionDepthStencilResolve": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "depthResolveMode": {"$ref": "#/definitions/VkResolveModeFlagBits"}, + "stencilResolveMode": {"$ref": "#/definitions/VkResolveModeFlagBits"}, + "pDepthStencilResolveAttachment": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/VkAttachmentReference2"}]} + } + }, + + "VkPhysicalDeviceDepthStencilResolveProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "supportedDepthResolveModes": {"$ref": "#/definitions/VkResolveModeFlags"}, + "supportedStencilResolveModes": {"$ref": "#/definitions/VkResolveModeFlags"}, + "independentResolveNone": {"$ref": "#/definitions/VkBool32"}, + "independentResolve": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceScalarBlockLayoutFeatures": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "scalarBlockLayout": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkImageStencilUsageCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "stencilUsage": {"$ref": "#/definitions/VkImageUsageFlags"} + } + }, + + "VkSamplerReductionModeCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "reductionMode": {"$ref": "#/definitions/VkSamplerReductionMode"} + } + }, + + "VkPhysicalDeviceSamplerFilterMinmaxProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "filterMinmaxSingleComponentFormats": {"$ref": "#/definitions/VkBool32"}, + "filterMinmaxImageComponentMapping": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceVulkanMemoryModelFeatures": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "vulkanMemoryModel": {"$ref": "#/definitions/VkBool32"}, + "vulkanMemoryModelDeviceScope": {"$ref": "#/definitions/VkBool32"}, + "vulkanMemoryModelAvailabilityVisibilityChains": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceImagelessFramebufferFeatures": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "imagelessFramebuffer": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkFramebufferAttachmentImageInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkImageCreateFlags"}, + "usage": {"$ref": "#/definitions/VkImageUsageFlags"}, + "width": {"$ref": "#/definitions/uint32_t"}, + "height": {"$ref": "#/definitions/uint32_t"}, + "layerCount": {"$ref": "#/definitions/uint32_t"}, + "viewFormatCount": {"$ref": "#/definitions/uint32_t"}, + "pViewFormats": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkFormat"}}]} + } + }, + + "VkFramebufferAttachmentsCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "attachmentImageInfoCount": {"$ref": "#/definitions/uint32_t"}, + "pAttachmentImageInfos": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkFramebufferAttachmentImageInfo"}}]} + } + }, + + "VkRenderPassAttachmentBeginInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "attachmentCount": {"$ref": "#/definitions/uint32_t"}, + "pAttachments": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkImageView"}}]} + } + }, + + "VkPhysicalDeviceUniformBufferStandardLayoutFeatures": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "uniformBufferStandardLayout": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "shaderSubgroupExtendedTypes": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "separateDepthStencilLayouts": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkAttachmentReferenceStencilLayout": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "stencilLayout": {"$ref": "#/definitions/VkImageLayout"} + } + }, + + "VkAttachmentDescriptionStencilLayout": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "stencilInitialLayout": {"$ref": "#/definitions/VkImageLayout"}, + "stencilFinalLayout": {"$ref": "#/definitions/VkImageLayout"} + } + }, + + "VkPhysicalDeviceHostQueryResetFeatures": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "hostQueryReset": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceTimelineSemaphoreFeatures": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "timelineSemaphore": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceTimelineSemaphoreProperties": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "maxTimelineSemaphoreValueDifference": {"$ref": "#/definitions/uint64_t"} + } + }, + + "VkSemaphoreTypeCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "semaphoreType": {"$ref": "#/definitions/VkSemaphoreType"}, + "initialValue": {"$ref": "#/definitions/uint64_t"} + } + }, + + "VkTimelineSemaphoreSubmitInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "waitSemaphoreValueCount": {"$ref": "#/definitions/uint32_t"}, + "pWaitSemaphoreValues": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint64_t"}}]}, + "signalSemaphoreValueCount": {"$ref": "#/definitions/uint32_t"}, + "pSignalSemaphoreValues": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint64_t"}}]} + } + }, + + "VkSemaphoreWaitInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkSemaphoreWaitFlags"}, + "semaphoreCount": {"$ref": "#/definitions/uint32_t"}, + "pSemaphores": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkSemaphore"}}]}, + "pValues": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint64_t"}}]} + } + }, + + "VkSemaphoreSignalInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "semaphore": {"$ref": "#/definitions/VkSemaphore"}, + "value": {"$ref": "#/definitions/uint64_t"} + } + }, + + "VkPhysicalDeviceBufferDeviceAddressFeatures": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "bufferDeviceAddress": {"$ref": "#/definitions/VkBool32"}, + "bufferDeviceAddressCaptureReplay": {"$ref": "#/definitions/VkBool32"}, + "bufferDeviceAddressMultiDevice": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkBufferDeviceAddressInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "buffer": {"$ref": "#/definitions/VkBuffer"} + } + }, + + "VkBufferOpaqueCaptureAddressCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "opaqueCaptureAddress": {"$ref": "#/definitions/uint64_t"} + } + }, + + "VkMemoryOpaqueCaptureAddressAllocateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "opaqueCaptureAddress": {"$ref": "#/definitions/uint64_t"} + } + }, + + "VkDeviceMemoryOpaqueCaptureAddressInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "memory": {"$ref": "#/definitions/VkDeviceMemory"} + } + }, + + "VkFaultLevel": {"$ref": "#/definitions/enum"}, + "VkFaultType": {"$ref": "#/definitions/enum"}, + "VkFaultQueryBehavior": {"$ref": "#/definitions/enum"}, + "VkPipelineMatchControl": {"$ref": "#/definitions/enum"}, + "VkPipelineCacheValidationVersion": {"$ref": "#/definitions/enum"}, + "VkPhysicalDeviceVulkanSC10Features": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "shaderAtomicInstructions": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceVulkanSC10Properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "deviceNoDynamicHostAllocations": {"$ref": "#/definitions/VkBool32"}, + "deviceDestroyFreesMemory": {"$ref": "#/definitions/VkBool32"}, + "commandPoolMultipleCommandBuffersRecording": {"$ref": "#/definitions/VkBool32"}, + "commandPoolResetCommandBuffer": {"$ref": "#/definitions/VkBool32"}, + "commandBufferSimultaneousUse": {"$ref": "#/definitions/VkBool32"}, + "secondaryCommandBufferNullOrImagelessFramebuffer": {"$ref": "#/definitions/VkBool32"}, + "recycleDescriptorSetMemory": {"$ref": "#/definitions/VkBool32"}, + "recyclePipelineMemory": {"$ref": "#/definitions/VkBool32"}, + "maxRenderPassSubpasses": {"$ref": "#/definitions/uint32_t"}, + "maxRenderPassDependencies": {"$ref": "#/definitions/uint32_t"}, + "maxSubpassInputAttachments": {"$ref": "#/definitions/uint32_t"}, + "maxSubpassPreserveAttachments": {"$ref": "#/definitions/uint32_t"}, + "maxFramebufferAttachments": {"$ref": "#/definitions/uint32_t"}, + "maxDescriptorSetLayoutBindings": {"$ref": "#/definitions/uint32_t"}, + "maxQueryFaultCount": {"$ref": "#/definitions/uint32_t"}, + "maxCallbackFaultCount": {"$ref": "#/definitions/uint32_t"}, + "maxCommandPoolCommandBuffers": {"$ref": "#/definitions/uint32_t"}, + "maxCommandBufferSize": {"$ref": "#/definitions/VkDeviceSize"} + } + }, + + "VkPipelinePoolSize": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "poolEntrySize": {"$ref": "#/definitions/VkDeviceSize"}, + "poolEntryCount": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkDeviceObjectReservationCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "pipelineCacheCreateInfoCount": {"$ref": "#/definitions/uint32_t"}, + "pPipelineCacheCreateInfos": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkPipelineCacheCreateInfo"}}]}, + "pipelinePoolSizeCount": {"$ref": "#/definitions/uint32_t"}, + "pPipelinePoolSizes": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkPipelinePoolSize"}}]}, + "semaphoreRequestCount": {"$ref": "#/definitions/uint32_t"}, + "commandBufferRequestCount": {"$ref": "#/definitions/uint32_t"}, + "fenceRequestCount": {"$ref": "#/definitions/uint32_t"}, + "deviceMemoryRequestCount": {"$ref": "#/definitions/uint32_t"}, + "bufferRequestCount": {"$ref": "#/definitions/uint32_t"}, + "imageRequestCount": {"$ref": "#/definitions/uint32_t"}, + "eventRequestCount": {"$ref": "#/definitions/uint32_t"}, + "queryPoolRequestCount": {"$ref": "#/definitions/uint32_t"}, + "bufferViewRequestCount": {"$ref": "#/definitions/uint32_t"}, + "imageViewRequestCount": {"$ref": "#/definitions/uint32_t"}, + "layeredImageViewRequestCount": {"$ref": "#/definitions/uint32_t"}, + "pipelineCacheRequestCount": {"$ref": "#/definitions/uint32_t"}, + "pipelineLayoutRequestCount": {"$ref": "#/definitions/uint32_t"}, + "renderPassRequestCount": {"$ref": "#/definitions/uint32_t"}, + "graphicsPipelineRequestCount": {"$ref": "#/definitions/uint32_t"}, + "computePipelineRequestCount": {"$ref": "#/definitions/uint32_t"}, + "descriptorSetLayoutRequestCount": {"$ref": "#/definitions/uint32_t"}, + "samplerRequestCount": {"$ref": "#/definitions/uint32_t"}, + "descriptorPoolRequestCount": {"$ref": "#/definitions/uint32_t"}, + "descriptorSetRequestCount": {"$ref": "#/definitions/uint32_t"}, + "framebufferRequestCount": {"$ref": "#/definitions/uint32_t"}, + "commandPoolRequestCount": {"$ref": "#/definitions/uint32_t"}, + "samplerYcbcrConversionRequestCount": {"$ref": "#/definitions/uint32_t"}, + "surfaceRequestCount": {"$ref": "#/definitions/uint32_t"}, + "swapchainRequestCount": {"$ref": "#/definitions/uint32_t"}, + "displayModeRequestCount": {"$ref": "#/definitions/uint32_t"}, + "subpassDescriptionRequestCount": {"$ref": "#/definitions/uint32_t"}, + "attachmentDescriptionRequestCount": {"$ref": "#/definitions/uint32_t"}, + "descriptorSetLayoutBindingRequestCount": {"$ref": "#/definitions/uint32_t"}, + "descriptorSetLayoutBindingLimit": {"$ref": "#/definitions/uint32_t"}, + "maxImageViewMipLevels": {"$ref": "#/definitions/uint32_t"}, + "maxImageViewArrayLayers": {"$ref": "#/definitions/uint32_t"}, + "maxLayeredImageViewMipLevels": {"$ref": "#/definitions/uint32_t"}, + "maxOcclusionQueriesPerPool": {"$ref": "#/definitions/uint32_t"}, + "maxPipelineStatisticsQueriesPerPool": {"$ref": "#/definitions/uint32_t"}, + "maxTimestampQueriesPerPool": {"$ref": "#/definitions/uint32_t"}, + "maxImmutableSamplersPerDescriptorSetLayout": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkCommandPoolMemoryReservationCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "commandPoolReservedSize": {"$ref": "#/definitions/VkDeviceSize"}, + "commandPoolMaxCommandBuffers": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkCommandPoolMemoryConsumption": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "commandPoolAllocated": {"$ref": "#/definitions/VkDeviceSize"}, + "commandPoolReservedSize": {"$ref": "#/definitions/VkDeviceSize"}, + "commandBufferAllocated": {"$ref": "#/definitions/VkDeviceSize"} + } + }, + + "VkFaultData": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "faultLevel": {"$ref": "#/definitions/VkFaultLevel"}, + "faultType": {"$ref": "#/definitions/VkFaultType"} + } + }, + + "VkFaultCallbackInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "faultCount": {"$ref": "#/definitions/uint32_t"}, + "pFaults": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkFaultData"}}]}, + "pfnFaultCallback": {"$ref": "#/definitions/PFN_vkFaultCallbackFunction"} + } + }, + + "VkPipelineOfflineCreateInfo": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "pipelineIdentifier": {"$ref": "#/definitions/uint8_t"}, + "matchControl": {"$ref": "#/definitions/VkPipelineMatchControl"}, + "poolEntrySize": {"$ref": "#/definitions/VkDeviceSize"} + } + }, + + "VkPipelineCacheStageValidationIndexEntry": { + "type": "object", + "additionalProperties": false, + "properties": { + "codeSize": {"$ref": "#/definitions/uint64_t"}, + "codeOffset": {"$ref": "#/definitions/uint64_t"} + } + }, + + "VkPipelineCacheSafetyCriticalIndexEntry": { + "type": "object", + "additionalProperties": false, + "properties": { + "pipelineIdentifier": {"$ref": "#/definitions/uint8_t"}, + "pipelineMemorySize": {"$ref": "#/definitions/uint64_t"}, + "jsonSize": {"$ref": "#/definitions/uint64_t"}, + "jsonOffset": {"$ref": "#/definitions/uint64_t"}, + "stageIndexCount": {"$ref": "#/definitions/uint32_t"}, + "stageIndexStride": {"$ref": "#/definitions/uint32_t"}, + "stageIndexOffset": {"$ref": "#/definitions/uint64_t"} + } + }, + + "VkPipelineCacheHeaderVersionSafetyCriticalOne": { + "type": "object", + "additionalProperties": false, + "properties": { + "headerVersionOne": {"$ref": "#/definitions/VkPipelineCacheHeaderVersionOne"}, + "validationVersion": {"$ref": "#/definitions/VkPipelineCacheValidationVersion"}, + "implementationData": {"$ref": "#/definitions/uint32_t"}, + "pipelineIndexCount": {"$ref": "#/definitions/uint32_t"}, + "pipelineIndexStride": {"$ref": "#/definitions/uint32_t"}, + "pipelineIndexOffset": {"$ref": "#/definitions/uint64_t"} + } + }, + + "VkSurfaceKHR": {"$ref": "#/definitions/uint64_t"}, + "VkSurfaceTransformFlagBitsKHR": {"$ref": "#/definitions/enum"}, + "VkPresentModeKHR": {"$ref": "#/definitions/enum"}, + "VkColorSpaceKHR": {"$ref": "#/definitions/enum"}, + "VkCompositeAlphaFlagBitsKHR": {"$ref": "#/definitions/enum"}, + "VkCompositeAlphaFlagsKHR": {"$ref": "#/definitions/VkFlags"}, + "VkSurfaceTransformFlagsKHR": {"$ref": "#/definitions/VkFlags"}, + "VkSurfaceCapabilitiesKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "minImageCount": {"$ref": "#/definitions/uint32_t"}, + "maxImageCount": {"$ref": "#/definitions/uint32_t"}, + "currentExtent": {"$ref": "#/definitions/VkExtent2D"}, + "minImageExtent": {"$ref": "#/definitions/VkExtent2D"}, + "maxImageExtent": {"$ref": "#/definitions/VkExtent2D"}, + "maxImageArrayLayers": {"$ref": "#/definitions/uint32_t"}, + "supportedTransforms": {"$ref": "#/definitions/VkSurfaceTransformFlagsKHR"}, + "currentTransform": {"$ref": "#/definitions/VkSurfaceTransformFlagBitsKHR"}, + "supportedCompositeAlpha": {"$ref": "#/definitions/VkCompositeAlphaFlagsKHR"}, + "supportedUsageFlags": {"$ref": "#/definitions/VkImageUsageFlags"} + } + }, + + "VkSurfaceFormatKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "format": {"$ref": "#/definitions/VkFormat"}, + "colorSpace": {"$ref": "#/definitions/VkColorSpaceKHR"} + } + }, + + "VkSwapchainKHR": {"$ref": "#/definitions/uint64_t"}, + "VkSwapchainCreateFlagBitsKHR": {"$ref": "#/definitions/enum"}, + "VkDeviceGroupPresentModeFlagBitsKHR": {"$ref": "#/definitions/enum"}, + "VkSwapchainCreateFlagsKHR": {"$ref": "#/definitions/VkFlags"}, + "VkDeviceGroupPresentModeFlagsKHR": {"$ref": "#/definitions/VkFlags"}, + "VkSwapchainCreateInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkSwapchainCreateFlagsKHR"}, + "surface": {"$ref": "#/definitions/VkSurfaceKHR"}, + "minImageCount": {"$ref": "#/definitions/uint32_t"}, + "imageFormat": {"$ref": "#/definitions/VkFormat"}, + "imageColorSpace": {"$ref": "#/definitions/VkColorSpaceKHR"}, + "imageExtent": {"$ref": "#/definitions/VkExtent2D"}, + "imageArrayLayers": {"$ref": "#/definitions/uint32_t"}, + "imageUsage": {"$ref": "#/definitions/VkImageUsageFlags"}, + "imageSharingMode": {"$ref": "#/definitions/VkSharingMode"}, + "queueFamilyIndexCount": {"$ref": "#/definitions/uint32_t"}, + "pQueueFamilyIndices": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}}]}, + "preTransform": {"$ref": "#/definitions/VkSurfaceTransformFlagBitsKHR"}, + "compositeAlpha": {"$ref": "#/definitions/VkCompositeAlphaFlagBitsKHR"}, + "presentMode": {"$ref": "#/definitions/VkPresentModeKHR"}, + "clipped": {"$ref": "#/definitions/VkBool32"}, + "oldSwapchain": {"$ref": "#/definitions/VkSwapchainKHR"} + } + }, + + "VkPresentInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "waitSemaphoreCount": {"$ref": "#/definitions/uint32_t"}, + "pWaitSemaphores": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkSemaphore"}}]}, + "swapchainCount": {"$ref": "#/definitions/uint32_t"}, + "pSwapchains": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkSwapchainKHR"}}]}, + "pImageIndices": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}}]}, + "pResults": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkResult"}}]} + } + }, + + "VkImageSwapchainCreateInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "swapchain": {"$ref": "#/definitions/VkSwapchainKHR"} + } + }, + + "VkBindImageMemorySwapchainInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "swapchain": {"$ref": "#/definitions/VkSwapchainKHR"}, + "imageIndex": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkAcquireNextImageInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "swapchain": {"$ref": "#/definitions/VkSwapchainKHR"}, + "timeout": {"$ref": "#/definitions/uint64_t"}, + "semaphore": {"$ref": "#/definitions/VkSemaphore"}, + "fence": {"$ref": "#/definitions/VkFence"}, + "deviceMask": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkDeviceGroupPresentCapabilitiesKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "presentMask": {"$ref": "#/definitions/uint32_t"}, + "modes": {"$ref": "#/definitions/VkDeviceGroupPresentModeFlagsKHR"} + } + }, + + "VkDeviceGroupPresentInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "swapchainCount": {"$ref": "#/definitions/uint32_t"}, + "pDeviceMasks": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}}]}, + "mode": {"$ref": "#/definitions/VkDeviceGroupPresentModeFlagBitsKHR"} + } + }, + + "VkDeviceGroupSwapchainCreateInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "modes": {"$ref": "#/definitions/VkDeviceGroupPresentModeFlagsKHR"} + } + }, + + "VkDisplayKHR": {"$ref": "#/definitions/uint64_t"}, + "VkDisplayModeKHR": {"$ref": "#/definitions/uint64_t"}, + "VkDisplayPlaneAlphaFlagBitsKHR": {"$ref": "#/definitions/enum"}, + "VkDisplayModeCreateFlagsKHR": {"$ref": "#/definitions/VkFlags"}, + "VkDisplayPlaneAlphaFlagsKHR": {"$ref": "#/definitions/VkFlags"}, + "VkDisplaySurfaceCreateFlagsKHR": {"$ref": "#/definitions/VkFlags"}, + "VkDisplayModeParametersKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "visibleRegion": {"$ref": "#/definitions/VkExtent2D"}, + "refreshRate": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkDisplayModeCreateInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkDisplayModeCreateFlagsKHR"}, + "parameters": {"$ref": "#/definitions/VkDisplayModeParametersKHR"} + } + }, + + "VkDisplayModePropertiesKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "displayMode": {"$ref": "#/definitions/VkDisplayModeKHR"}, + "parameters": {"$ref": "#/definitions/VkDisplayModeParametersKHR"} + } + }, + + "VkDisplayPlaneCapabilitiesKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "supportedAlpha": {"$ref": "#/definitions/VkDisplayPlaneAlphaFlagsKHR"}, + "minSrcPosition": {"$ref": "#/definitions/VkOffset2D"}, + "maxSrcPosition": {"$ref": "#/definitions/VkOffset2D"}, + "minSrcExtent": {"$ref": "#/definitions/VkExtent2D"}, + "maxSrcExtent": {"$ref": "#/definitions/VkExtent2D"}, + "minDstPosition": {"$ref": "#/definitions/VkOffset2D"}, + "maxDstPosition": {"$ref": "#/definitions/VkOffset2D"}, + "minDstExtent": {"$ref": "#/definitions/VkExtent2D"}, + "maxDstExtent": {"$ref": "#/definitions/VkExtent2D"} + } + }, + + "VkDisplayPlanePropertiesKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "currentDisplay": {"$ref": "#/definitions/VkDisplayKHR"}, + "currentStackIndex": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkDisplayPropertiesKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "display": {"$ref": "#/definitions/VkDisplayKHR"}, + "displayName": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/char"}]}, + "physicalDimensions": {"$ref": "#/definitions/VkExtent2D"}, + "physicalResolution": {"$ref": "#/definitions/VkExtent2D"}, + "supportedTransforms": {"$ref": "#/definitions/VkSurfaceTransformFlagsKHR"}, + "planeReorderPossible": {"$ref": "#/definitions/VkBool32"}, + "persistentContent": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkDisplaySurfaceCreateInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkDisplaySurfaceCreateFlagsKHR"}, + "displayMode": {"$ref": "#/definitions/VkDisplayModeKHR"}, + "planeIndex": {"$ref": "#/definitions/uint32_t"}, + "planeStackIndex": {"$ref": "#/definitions/uint32_t"}, + "transform": {"$ref": "#/definitions/VkSurfaceTransformFlagBitsKHR"}, + "globalAlpha": {"$ref": "#/definitions/float"}, + "alphaMode": {"$ref": "#/definitions/VkDisplayPlaneAlphaFlagBitsKHR"}, + "imageExtent": {"$ref": "#/definitions/VkExtent2D"} + } + }, + + "VkDisplayPresentInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "srcRect": {"$ref": "#/definitions/VkRect2D"}, + "dstRect": {"$ref": "#/definitions/VkRect2D"}, + "persistent": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkImportMemoryFdInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "handleType": {"$ref": "#/definitions/VkExternalMemoryHandleTypeFlagBits"}, + "fd": {"$ref": "#/definitions/int"} + } + }, + + "VkMemoryFdPropertiesKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "memoryTypeBits": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkMemoryGetFdInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "memory": {"$ref": "#/definitions/VkDeviceMemory"}, + "handleType": {"$ref": "#/definitions/VkExternalMemoryHandleTypeFlagBits"} + } + }, + + "VkImportSemaphoreFdInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "semaphore": {"$ref": "#/definitions/VkSemaphore"}, + "flags": {"$ref": "#/definitions/VkSemaphoreImportFlags"}, + "handleType": {"$ref": "#/definitions/VkExternalSemaphoreHandleTypeFlagBits"}, + "fd": {"$ref": "#/definitions/int"} + } + }, + + "VkSemaphoreGetFdInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "semaphore": {"$ref": "#/definitions/VkSemaphore"}, + "handleType": {"$ref": "#/definitions/VkExternalSemaphoreHandleTypeFlagBits"} + } + }, + + "VkRectLayerKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "offset": {"$ref": "#/definitions/VkOffset2D"}, + "extent": {"$ref": "#/definitions/VkExtent2D"}, + "layer": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkPresentRegionKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "rectangleCount": {"$ref": "#/definitions/uint32_t"}, + "pRectangles": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkRectLayerKHR"}}]} + } + }, + + "VkPresentRegionsKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "swapchainCount": {"$ref": "#/definitions/uint32_t"}, + "pRegions": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkPresentRegionKHR"}}]} + } + }, + + "VkSharedPresentSurfaceCapabilitiesKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "sharedPresentSupportedUsageFlags": {"$ref": "#/definitions/VkImageUsageFlags"} + } + }, + + "VkImportFenceFdInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "fence": {"$ref": "#/definitions/VkFence"}, + "flags": {"$ref": "#/definitions/VkFenceImportFlags"}, + "handleType": {"$ref": "#/definitions/VkExternalFenceHandleTypeFlagBits"}, + "fd": {"$ref": "#/definitions/int"} + } + }, + + "VkFenceGetFdInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "fence": {"$ref": "#/definitions/VkFence"}, + "handleType": {"$ref": "#/definitions/VkExternalFenceHandleTypeFlagBits"} + } + }, + + "VkPerformanceCounterUnitKHR": {"$ref": "#/definitions/enum"}, + "VkPerformanceCounterScopeKHR": {"$ref": "#/definitions/enum"}, + "VkPerformanceCounterStorageKHR": {"$ref": "#/definitions/enum"}, + "VkPerformanceCounterDescriptionFlagBitsKHR": {"$ref": "#/definitions/enum"}, + "VkAcquireProfilingLockFlagBitsKHR": {"$ref": "#/definitions/enum"}, + "VkPerformanceCounterDescriptionFlagsKHR": {"$ref": "#/definitions/VkFlags"}, + "VkAcquireProfilingLockFlagsKHR": {"$ref": "#/definitions/VkFlags"}, + "VkPhysicalDevicePerformanceQueryFeaturesKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "performanceCounterQueryPools": {"$ref": "#/definitions/VkBool32"}, + "performanceCounterMultipleQueryPools": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDevicePerformanceQueryPropertiesKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "allowCommandBufferQueryCopies": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPerformanceCounterKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "unit": {"$ref": "#/definitions/VkPerformanceCounterUnitKHR"}, + "scope": {"$ref": "#/definitions/VkPerformanceCounterScopeKHR"}, + "storage": {"$ref": "#/definitions/VkPerformanceCounterStorageKHR"}, + "uuid": {"$ref": "#/definitions/uint8_t"} + } + }, + + "VkPerformanceCounterDescriptionKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkPerformanceCounterDescriptionFlagsKHR"}, + "name": {"$ref": "#/definitions/char"}, + "category": {"$ref": "#/definitions/char"}, + "description": {"$ref": "#/definitions/char"} + } + }, + + "VkQueryPoolPerformanceCreateInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "queueFamilyIndex": {"$ref": "#/definitions/uint32_t"}, + "counterIndexCount": {"$ref": "#/definitions/uint32_t"}, + "pCounterIndices": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}}]} + } + }, + + "VkPerformanceCounterResultKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "int32": {"$ref": "#/definitions/int32_t"}, + "int64": {"$ref": "#/definitions/int64_t"}, + "uint32": {"$ref": "#/definitions/uint32_t"}, + "uint64": {"$ref": "#/definitions/uint64_t"}, + "float32": {"$ref": "#/definitions/float"}, + "float64": {"$ref": "#/definitions/double"} + } + }, + + "VkAcquireProfilingLockInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkAcquireProfilingLockFlagsKHR"}, + "timeout": {"$ref": "#/definitions/uint64_t"} + } + }, + + "VkPerformanceQuerySubmitInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "counterPassIndex": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkPerformanceQueryReservationInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "maxPerformanceQueriesPerPool": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkPhysicalDeviceSurfaceInfo2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "surface": {"$ref": "#/definitions/VkSurfaceKHR"} + } + }, + + "VkSurfaceCapabilities2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "surfaceCapabilities": {"$ref": "#/definitions/VkSurfaceCapabilitiesKHR"} + } + }, + + "VkSurfaceFormat2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "surfaceFormat": {"$ref": "#/definitions/VkSurfaceFormatKHR"} + } + }, + + "VkDisplayProperties2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "displayProperties": {"$ref": "#/definitions/VkDisplayPropertiesKHR"} + } + }, + + "VkDisplayPlaneProperties2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "displayPlaneProperties": {"$ref": "#/definitions/VkDisplayPlanePropertiesKHR"} + } + }, + + "VkDisplayModeProperties2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "displayModeProperties": {"$ref": "#/definitions/VkDisplayModePropertiesKHR"} + } + }, + + "VkDisplayPlaneInfo2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "mode": {"$ref": "#/definitions/VkDisplayModeKHR"}, + "planeIndex": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkDisplayPlaneCapabilities2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "capabilities": {"$ref": "#/definitions/VkDisplayPlaneCapabilitiesKHR"} + } + }, + + "VkPhysicalDeviceShaderClockFeaturesKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "shaderSubgroupClock": {"$ref": "#/definitions/VkBool32"}, + "shaderDeviceClock": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "shaderTerminateInvocation": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkFragmentShadingRateCombinerOpKHR": {"$ref": "#/definitions/enum"}, + "VkFragmentShadingRateAttachmentInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "pFragmentShadingRateAttachment": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/VkAttachmentReference2"}]}, + "shadingRateAttachmentTexelSize": {"$ref": "#/definitions/VkExtent2D"} + } + }, + + "VkPipelineFragmentShadingRateStateCreateInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "fragmentSize": {"$ref": "#/definitions/VkExtent2D"}, + "combinerOps": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkFragmentShadingRateCombinerOpKHR"}} + } + }, + + "VkPhysicalDeviceFragmentShadingRateFeaturesKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "pipelineFragmentShadingRate": {"$ref": "#/definitions/VkBool32"}, + "primitiveFragmentShadingRate": {"$ref": "#/definitions/VkBool32"}, + "attachmentFragmentShadingRate": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceFragmentShadingRatePropertiesKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "minFragmentShadingRateAttachmentTexelSize": {"$ref": "#/definitions/VkExtent2D"}, + "maxFragmentShadingRateAttachmentTexelSize": {"$ref": "#/definitions/VkExtent2D"}, + "maxFragmentShadingRateAttachmentTexelSizeAspectRatio": {"$ref": "#/definitions/uint32_t"}, + "primitiveFragmentShadingRateWithMultipleViewports": {"$ref": "#/definitions/VkBool32"}, + "layeredShadingRateAttachments": {"$ref": "#/definitions/VkBool32"}, + "fragmentShadingRateNonTrivialCombinerOps": {"$ref": "#/definitions/VkBool32"}, + "maxFragmentSize": {"$ref": "#/definitions/VkExtent2D"}, + "maxFragmentSizeAspectRatio": {"$ref": "#/definitions/uint32_t"}, + "maxFragmentShadingRateCoverageSamples": {"$ref": "#/definitions/uint32_t"}, + "maxFragmentShadingRateRasterizationSamples": {"$ref": "#/definitions/VkSampleCountFlagBits"}, + "fragmentShadingRateWithShaderDepthStencilWrites": {"$ref": "#/definitions/VkBool32"}, + "fragmentShadingRateWithSampleMask": {"$ref": "#/definitions/VkBool32"}, + "fragmentShadingRateWithShaderSampleMask": {"$ref": "#/definitions/VkBool32"}, + "fragmentShadingRateWithConservativeRasterization": {"$ref": "#/definitions/VkBool32"}, + "fragmentShadingRateWithFragmentShaderInterlock": {"$ref": "#/definitions/VkBool32"}, + "fragmentShadingRateWithCustomSampleLocations": {"$ref": "#/definitions/VkBool32"}, + "fragmentShadingRateStrictMultiplyCombiner": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceFragmentShadingRateKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "sampleCounts": {"$ref": "#/definitions/VkSampleCountFlags"}, + "fragmentSize": {"$ref": "#/definitions/VkExtent2D"} + } + }, + + "VkRefreshObjectFlagBitsKHR": {"$ref": "#/definitions/enum"}, + "VkRefreshObjectFlagsKHR": {"$ref": "#/definitions/VkFlags"}, + "VkRefreshObjectKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "objectType": {"$ref": "#/definitions/VkObjectType"}, + "objectHandle": {"$ref": "#/definitions/uint64_t"}, + "flags": {"$ref": "#/definitions/VkRefreshObjectFlagsKHR"} + } + }, + + "VkRefreshObjectListKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "objectCount": {"$ref": "#/definitions/uint32_t"}, + "pObjects": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkRefreshObjectKHR"}}]} + } + }, + + "VkPipelineStageFlagBits2KHR": {"$ref": "#/definitions/enum"}, + "VkAccessFlagBits2KHR": {"$ref": "#/definitions/enum"}, + "VkSubmitFlagBitsKHR": {"$ref": "#/definitions/enum"}, + "VkFlags64": {"$ref": "#/definitions/uint64_t"}, + "VkPipelineStageFlags2KHR": {"$ref": "#/definitions/VkFlags64"}, + "VkAccessFlags2KHR": {"$ref": "#/definitions/VkFlags64"}, + "VkSubmitFlagsKHR": {"$ref": "#/definitions/VkFlags"}, + "VkMemoryBarrier2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "srcStageMask": {"$ref": "#/definitions/VkPipelineStageFlags2KHR"}, + "srcAccessMask": {"$ref": "#/definitions/VkAccessFlags2KHR"}, + "dstStageMask": {"$ref": "#/definitions/VkPipelineStageFlags2KHR"}, + "dstAccessMask": {"$ref": "#/definitions/VkAccessFlags2KHR"} + } + }, + + "VkBufferMemoryBarrier2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "srcStageMask": {"$ref": "#/definitions/VkPipelineStageFlags2KHR"}, + "srcAccessMask": {"$ref": "#/definitions/VkAccessFlags2KHR"}, + "dstStageMask": {"$ref": "#/definitions/VkPipelineStageFlags2KHR"}, + "dstAccessMask": {"$ref": "#/definitions/VkAccessFlags2KHR"}, + "srcQueueFamilyIndex": {"$ref": "#/definitions/uint32_t"}, + "dstQueueFamilyIndex": {"$ref": "#/definitions/uint32_t"}, + "buffer": {"$ref": "#/definitions/VkBuffer"}, + "offset": {"$ref": "#/definitions/VkDeviceSize"}, + "size": {"$ref": "#/definitions/VkDeviceSize"} + } + }, + + "VkImageMemoryBarrier2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "srcStageMask": {"$ref": "#/definitions/VkPipelineStageFlags2KHR"}, + "srcAccessMask": {"$ref": "#/definitions/VkAccessFlags2KHR"}, + "dstStageMask": {"$ref": "#/definitions/VkPipelineStageFlags2KHR"}, + "dstAccessMask": {"$ref": "#/definitions/VkAccessFlags2KHR"}, + "oldLayout": {"$ref": "#/definitions/VkImageLayout"}, + "newLayout": {"$ref": "#/definitions/VkImageLayout"}, + "srcQueueFamilyIndex": {"$ref": "#/definitions/uint32_t"}, + "dstQueueFamilyIndex": {"$ref": "#/definitions/uint32_t"}, + "image": {"$ref": "#/definitions/VkImage"}, + "subresourceRange": {"$ref": "#/definitions/VkImageSubresourceRange"} + } + }, + + "VkDependencyInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "dependencyFlags": {"$ref": "#/definitions/VkDependencyFlags"}, + "memoryBarrierCount": {"$ref": "#/definitions/uint32_t"}, + "pMemoryBarriers": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkMemoryBarrier2KHR"}}]}, + "bufferMemoryBarrierCount": {"$ref": "#/definitions/uint32_t"}, + "pBufferMemoryBarriers": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkBufferMemoryBarrier2KHR"}}]}, + "imageMemoryBarrierCount": {"$ref": "#/definitions/uint32_t"}, + "pImageMemoryBarriers": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkImageMemoryBarrier2KHR"}}]} + } + }, + + "VkSemaphoreSubmitInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "semaphore": {"$ref": "#/definitions/VkSemaphore"}, + "value": {"$ref": "#/definitions/uint64_t"}, + "stageMask": {"$ref": "#/definitions/VkPipelineStageFlags2KHR"}, + "deviceIndex": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkCommandBufferSubmitInfoKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "commandBuffer": {"$ref": "#/definitions/VkCommandBuffer"}, + "deviceMask": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkSubmitInfo2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkSubmitFlagsKHR"}, + "waitSemaphoreInfoCount": {"$ref": "#/definitions/uint32_t"}, + "pWaitSemaphoreInfos": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkSemaphoreSubmitInfoKHR"}}]}, + "commandBufferInfoCount": {"$ref": "#/definitions/uint32_t"}, + "pCommandBufferInfos": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkCommandBufferSubmitInfoKHR"}}]}, + "signalSemaphoreInfoCount": {"$ref": "#/definitions/uint32_t"}, + "pSignalSemaphoreInfos": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkSemaphoreSubmitInfoKHR"}}]} + } + }, + + "VkPhysicalDeviceSynchronization2FeaturesKHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "synchronization2": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkQueueFamilyCheckpointProperties2NV": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "checkpointExecutionStageMask": {"$ref": "#/definitions/VkPipelineStageFlags2KHR"} + } + }, + + "VkCheckpointData2NV": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "stage": {"$ref": "#/definitions/VkPipelineStageFlags2KHR"}, + "pCheckpointMarker": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/void"}]} + } + }, + + "VkBufferCopy2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "srcOffset": {"$ref": "#/definitions/VkDeviceSize"}, + "dstOffset": {"$ref": "#/definitions/VkDeviceSize"}, + "size": {"$ref": "#/definitions/VkDeviceSize"} + } + }, + + "VkCopyBufferInfo2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "srcBuffer": {"$ref": "#/definitions/VkBuffer"}, + "dstBuffer": {"$ref": "#/definitions/VkBuffer"}, + "regionCount": {"$ref": "#/definitions/uint32_t"}, + "pRegions": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkBufferCopy2KHR"}}]} + } + }, + + "VkImageCopy2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "srcSubresource": {"$ref": "#/definitions/VkImageSubresourceLayers"}, + "srcOffset": {"$ref": "#/definitions/VkOffset3D"}, + "dstSubresource": {"$ref": "#/definitions/VkImageSubresourceLayers"}, + "dstOffset": {"$ref": "#/definitions/VkOffset3D"}, + "extent": {"$ref": "#/definitions/VkExtent3D"} + } + }, + + "VkCopyImageInfo2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "srcImage": {"$ref": "#/definitions/VkImage"}, + "srcImageLayout": {"$ref": "#/definitions/VkImageLayout"}, + "dstImage": {"$ref": "#/definitions/VkImage"}, + "dstImageLayout": {"$ref": "#/definitions/VkImageLayout"}, + "regionCount": {"$ref": "#/definitions/uint32_t"}, + "pRegions": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkImageCopy2KHR"}}]} + } + }, + + "VkBufferImageCopy2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "bufferOffset": {"$ref": "#/definitions/VkDeviceSize"}, + "bufferRowLength": {"$ref": "#/definitions/uint32_t"}, + "bufferImageHeight": {"$ref": "#/definitions/uint32_t"}, + "imageSubresource": {"$ref": "#/definitions/VkImageSubresourceLayers"}, + "imageOffset": {"$ref": "#/definitions/VkOffset3D"}, + "imageExtent": {"$ref": "#/definitions/VkExtent3D"} + } + }, + + "VkCopyBufferToImageInfo2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "srcBuffer": {"$ref": "#/definitions/VkBuffer"}, + "dstImage": {"$ref": "#/definitions/VkImage"}, + "dstImageLayout": {"$ref": "#/definitions/VkImageLayout"}, + "regionCount": {"$ref": "#/definitions/uint32_t"}, + "pRegions": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkBufferImageCopy2KHR"}}]} + } + }, + + "VkCopyImageToBufferInfo2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "srcImage": {"$ref": "#/definitions/VkImage"}, + "srcImageLayout": {"$ref": "#/definitions/VkImageLayout"}, + "dstBuffer": {"$ref": "#/definitions/VkBuffer"}, + "regionCount": {"$ref": "#/definitions/uint32_t"}, + "pRegions": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkBufferImageCopy2KHR"}}]} + } + }, + + "VkImageBlit2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "srcSubresource": {"$ref": "#/definitions/VkImageSubresourceLayers"}, + "srcOffsets": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkOffset3D"}}, + "dstSubresource": {"$ref": "#/definitions/VkImageSubresourceLayers"}, + "dstOffsets": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkOffset3D"}} + } + }, + + "VkBlitImageInfo2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "srcImage": {"$ref": "#/definitions/VkImage"}, + "srcImageLayout": {"$ref": "#/definitions/VkImageLayout"}, + "dstImage": {"$ref": "#/definitions/VkImage"}, + "dstImageLayout": {"$ref": "#/definitions/VkImageLayout"}, + "regionCount": {"$ref": "#/definitions/uint32_t"}, + "pRegions": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkImageBlit2KHR"}}]}, + "filter": {"$ref": "#/definitions/VkFilter"} + } + }, + + "VkImageResolve2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "srcSubresource": {"$ref": "#/definitions/VkImageSubresourceLayers"}, + "srcOffset": {"$ref": "#/definitions/VkOffset3D"}, + "dstSubresource": {"$ref": "#/definitions/VkImageSubresourceLayers"}, + "dstOffset": {"$ref": "#/definitions/VkOffset3D"}, + "extent": {"$ref": "#/definitions/VkExtent3D"} + } + }, + + "VkResolveImageInfo2KHR": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "srcImage": {"$ref": "#/definitions/VkImage"}, + "srcImageLayout": {"$ref": "#/definitions/VkImageLayout"}, + "dstImage": {"$ref": "#/definitions/VkImage"}, + "dstImageLayout": {"$ref": "#/definitions/VkImageLayout"}, + "regionCount": {"$ref": "#/definitions/uint32_t"}, + "pRegions": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkImageResolve2KHR"}}]} + } + }, + + "VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "textureCompressionASTC_HDR": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkImageViewASTCDecodeModeEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "decodeMode": {"$ref": "#/definitions/VkFormat"} + } + }, + + "VkPhysicalDeviceASTCDecodeFeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "decodeModeSharedExponent": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkSurfaceCounterFlagBitsEXT": {"$ref": "#/definitions/enum"}, + "VkSurfaceCounterFlagsEXT": {"$ref": "#/definitions/VkFlags"}, + "VkSurfaceCapabilities2EXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "minImageCount": {"$ref": "#/definitions/uint32_t"}, + "maxImageCount": {"$ref": "#/definitions/uint32_t"}, + "currentExtent": {"$ref": "#/definitions/VkExtent2D"}, + "minImageExtent": {"$ref": "#/definitions/VkExtent2D"}, + "maxImageExtent": {"$ref": "#/definitions/VkExtent2D"}, + "maxImageArrayLayers": {"$ref": "#/definitions/uint32_t"}, + "supportedTransforms": {"$ref": "#/definitions/VkSurfaceTransformFlagsKHR"}, + "currentTransform": {"$ref": "#/definitions/VkSurfaceTransformFlagBitsKHR"}, + "supportedCompositeAlpha": {"$ref": "#/definitions/VkCompositeAlphaFlagsKHR"}, + "supportedUsageFlags": {"$ref": "#/definitions/VkImageUsageFlags"}, + "supportedSurfaceCounters": {"$ref": "#/definitions/VkSurfaceCounterFlagsEXT"} + } + }, + + "VkDisplayPowerStateEXT": {"$ref": "#/definitions/enum"}, + "VkDeviceEventTypeEXT": {"$ref": "#/definitions/enum"}, + "VkDisplayEventTypeEXT": {"$ref": "#/definitions/enum"}, + "VkDisplayPowerInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "powerState": {"$ref": "#/definitions/VkDisplayPowerStateEXT"} + } + }, + + "VkDeviceEventInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "deviceEvent": {"$ref": "#/definitions/VkDeviceEventTypeEXT"} + } + }, + + "VkDisplayEventInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "displayEvent": {"$ref": "#/definitions/VkDisplayEventTypeEXT"} + } + }, + + "VkSwapchainCounterCreateInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "surfaceCounters": {"$ref": "#/definitions/VkSurfaceCounterFlagsEXT"} + } + }, + + "VkDiscardRectangleModeEXT": {"$ref": "#/definitions/enum"}, + "VkPipelineDiscardRectangleStateCreateFlagsEXT": {"$ref": "#/definitions/VkFlags"}, + "VkPhysicalDeviceDiscardRectanglePropertiesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "maxDiscardRectangles": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkPipelineDiscardRectangleStateCreateInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkPipelineDiscardRectangleStateCreateFlagsEXT"}, + "discardRectangleMode": {"$ref": "#/definitions/VkDiscardRectangleModeEXT"}, + "discardRectangleCount": {"$ref": "#/definitions/uint32_t"}, + "pDiscardRectangles": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkRect2D"}}]} + } + }, + + "VkConservativeRasterizationModeEXT": {"$ref": "#/definitions/enum"}, + "VkPipelineRasterizationConservativeStateCreateFlagsEXT": {"$ref": "#/definitions/VkFlags"}, + "VkPhysicalDeviceConservativeRasterizationPropertiesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "primitiveOverestimationSize": {"$ref": "#/definitions/float"}, + "maxExtraPrimitiveOverestimationSize": {"$ref": "#/definitions/float"}, + "extraPrimitiveOverestimationSizeGranularity": {"$ref": "#/definitions/float"}, + "primitiveUnderestimation": {"$ref": "#/definitions/VkBool32"}, + "conservativePointAndLineRasterization": {"$ref": "#/definitions/VkBool32"}, + "degenerateTrianglesRasterized": {"$ref": "#/definitions/VkBool32"}, + "degenerateLinesRasterized": {"$ref": "#/definitions/VkBool32"}, + "fullyCoveredFragmentShaderInputVariable": {"$ref": "#/definitions/VkBool32"}, + "conservativeRasterizationPostDepthCoverage": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPipelineRasterizationConservativeStateCreateInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkPipelineRasterizationConservativeStateCreateFlagsEXT"}, + "conservativeRasterizationMode": {"$ref": "#/definitions/VkConservativeRasterizationModeEXT"}, + "extraPrimitiveOverestimationSize": {"$ref": "#/definitions/float"} + } + }, + + "VkPipelineRasterizationDepthClipStateCreateFlagsEXT": {"$ref": "#/definitions/VkFlags"}, + "VkPhysicalDeviceDepthClipEnableFeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "depthClipEnable": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPipelineRasterizationDepthClipStateCreateInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkPipelineRasterizationDepthClipStateCreateFlagsEXT"}, + "depthClipEnable": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkXYColorEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "x": {"$ref": "#/definitions/float"}, + "y": {"$ref": "#/definitions/float"} + } + }, + + "VkHdrMetadataEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "displayPrimaryRed": {"$ref": "#/definitions/VkXYColorEXT"}, + "displayPrimaryGreen": {"$ref": "#/definitions/VkXYColorEXT"}, + "displayPrimaryBlue": {"$ref": "#/definitions/VkXYColorEXT"}, + "whitePoint": {"$ref": "#/definitions/VkXYColorEXT"}, + "maxLuminance": {"$ref": "#/definitions/float"}, + "minLuminance": {"$ref": "#/definitions/float"}, + "maxContentLightLevel": {"$ref": "#/definitions/float"}, + "maxFrameAverageLightLevel": {"$ref": "#/definitions/float"} + } + }, + + "VkDebugUtilsMessengerEXT": {"$ref": "#/definitions/uint64_t"}, + "VkDebugUtilsMessageSeverityFlagBitsEXT": {"$ref": "#/definitions/enum"}, + "VkDebugUtilsMessageTypeFlagBitsEXT": {"$ref": "#/definitions/enum"}, + "VkDebugUtilsMessengerCallbackDataFlagsEXT": {"$ref": "#/definitions/VkFlags"}, + "VkDebugUtilsMessageTypeFlagsEXT": {"$ref": "#/definitions/VkFlags"}, + "VkDebugUtilsMessageSeverityFlagsEXT": {"$ref": "#/definitions/VkFlags"}, + "VkDebugUtilsMessengerCreateFlagsEXT": {"$ref": "#/definitions/VkFlags"}, + "VkDebugUtilsLabelEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "pLabelName": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/char"}]}, + "color": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/float"}} + } + }, + + "VkDebugUtilsObjectNameInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "objectType": {"$ref": "#/definitions/VkObjectType"}, + "objectHandle": {"$ref": "#/definitions/uint64_t"}, + "pObjectName": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/char"}]} + } + }, + + "VkDebugUtilsMessengerCallbackDataEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkDebugUtilsMessengerCallbackDataFlagsEXT"}, + "pMessageIdName": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/char"}]}, + "messageIdNumber": {"$ref": "#/definitions/int32_t"}, + "pMessage": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/char"}]}, + "queueLabelCount": {"$ref": "#/definitions/uint32_t"}, + "pQueueLabels": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkDebugUtilsLabelEXT"}}]}, + "cmdBufLabelCount": {"$ref": "#/definitions/uint32_t"}, + "pCmdBufLabels": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkDebugUtilsLabelEXT"}}]}, + "objectCount": {"$ref": "#/definitions/uint32_t"}, + "pObjects": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkDebugUtilsObjectNameInfoEXT"}}]} + } + }, + + "VkDebugUtilsMessengerCreateInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkDebugUtilsMessengerCreateFlagsEXT"}, + "messageSeverity": {"$ref": "#/definitions/VkDebugUtilsMessageSeverityFlagsEXT"}, + "messageType": {"$ref": "#/definitions/VkDebugUtilsMessageTypeFlagsEXT"}, + "pfnUserCallback": {"$ref": "#/definitions/PFN_vkDebugUtilsMessengerCallbackEXT"}, + "pUserData": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/void"}]} + } + }, + + "VkDebugUtilsObjectTagInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "objectType": {"$ref": "#/definitions/VkObjectType"}, + "objectHandle": {"$ref": "#/definitions/uint64_t"}, + "tagName": {"$ref": "#/definitions/uint64_t"}, + "tagSize": {"$ref": "#/definitions/size_t"}, + "pTag": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/void"}}]} + } + }, + + "VkSampleLocationEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "x": {"$ref": "#/definitions/float"}, + "y": {"$ref": "#/definitions/float"} + } + }, + + "VkSampleLocationsInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "sampleLocationsPerPixel": {"$ref": "#/definitions/VkSampleCountFlagBits"}, + "sampleLocationGridSize": {"$ref": "#/definitions/VkExtent2D"}, + "sampleLocationsCount": {"$ref": "#/definitions/uint32_t"}, + "pSampleLocations": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkSampleLocationEXT"}}]} + } + }, + + "VkAttachmentSampleLocationsEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "attachmentIndex": {"$ref": "#/definitions/uint32_t"}, + "sampleLocationsInfo": {"$ref": "#/definitions/VkSampleLocationsInfoEXT"} + } + }, + + "VkSubpassSampleLocationsEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "subpassIndex": {"$ref": "#/definitions/uint32_t"}, + "sampleLocationsInfo": {"$ref": "#/definitions/VkSampleLocationsInfoEXT"} + } + }, + + "VkRenderPassSampleLocationsBeginInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "attachmentInitialSampleLocationsCount": {"$ref": "#/definitions/uint32_t"}, + "pAttachmentInitialSampleLocations": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkAttachmentSampleLocationsEXT"}}]}, + "postSubpassSampleLocationsCount": {"$ref": "#/definitions/uint32_t"}, + "pPostSubpassSampleLocations": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkSubpassSampleLocationsEXT"}}]} + } + }, + + "VkPipelineSampleLocationsStateCreateInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "sampleLocationsEnable": {"$ref": "#/definitions/VkBool32"}, + "sampleLocationsInfo": {"$ref": "#/definitions/VkSampleLocationsInfoEXT"} + } + }, + + "VkPhysicalDeviceSampleLocationsPropertiesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "sampleLocationSampleCounts": {"$ref": "#/definitions/VkSampleCountFlags"}, + "maxSampleLocationGridSize": {"$ref": "#/definitions/VkExtent2D"}, + "sampleLocationCoordinateRange": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/float"}}, + "sampleLocationSubPixelBits": {"$ref": "#/definitions/uint32_t"}, + "variableSampleLocations": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkMultisamplePropertiesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "maxSampleLocationGridSize": {"$ref": "#/definitions/VkExtent2D"} + } + }, + + "VkBlendOverlapEXT": {"$ref": "#/definitions/enum"}, + "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "advancedBlendCoherentOperations": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "advancedBlendMaxColorAttachments": {"$ref": "#/definitions/uint32_t"}, + "advancedBlendIndependentBlend": {"$ref": "#/definitions/VkBool32"}, + "advancedBlendNonPremultipliedSrcColor": {"$ref": "#/definitions/VkBool32"}, + "advancedBlendNonPremultipliedDstColor": {"$ref": "#/definitions/VkBool32"}, + "advancedBlendCorrelatedOverlap": {"$ref": "#/definitions/VkBool32"}, + "advancedBlendAllOperations": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPipelineColorBlendAdvancedStateCreateInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "srcPremultiplied": {"$ref": "#/definitions/VkBool32"}, + "dstPremultiplied": {"$ref": "#/definitions/VkBool32"}, + "blendOverlap": {"$ref": "#/definitions/VkBlendOverlapEXT"} + } + }, + + "VkFormatFeatureFlagBits2KHR": {"$ref": "#/definitions/enum"}, + "VkFormatFeatureFlags2KHR": {"$ref": "#/definitions/VkFlags64"}, + "VkDrmFormatModifierPropertiesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "drmFormatModifier": {"$ref": "#/definitions/uint64_t"}, + "drmFormatModifierPlaneCount": {"$ref": "#/definitions/uint32_t"}, + "drmFormatModifierTilingFeatures": {"$ref": "#/definitions/VkFormatFeatureFlags"} + } + }, + + "VkDrmFormatModifierPropertiesListEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "drmFormatModifierCount": {"$ref": "#/definitions/uint32_t"}, + "pDrmFormatModifierProperties": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkDrmFormatModifierPropertiesEXT"}}]} + } + }, + + "VkPhysicalDeviceImageDrmFormatModifierInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "drmFormatModifier": {"$ref": "#/definitions/uint64_t"}, + "sharingMode": {"$ref": "#/definitions/VkSharingMode"}, + "queueFamilyIndexCount": {"$ref": "#/definitions/uint32_t"}, + "pQueueFamilyIndices": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint32_t"}}]} + } + }, + + "VkImageDrmFormatModifierListCreateInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "drmFormatModifierCount": {"$ref": "#/definitions/uint32_t"}, + "pDrmFormatModifiers": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/uint64_t"}}]} + } + }, + + "VkImageDrmFormatModifierExplicitCreateInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "drmFormatModifier": {"$ref": "#/definitions/uint64_t"}, + "drmFormatModifierPlaneCount": {"$ref": "#/definitions/uint32_t"}, + "pPlaneLayouts": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkSubresourceLayout"}}]} + } + }, + + "VkImageDrmFormatModifierPropertiesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "drmFormatModifier": {"$ref": "#/definitions/uint64_t"} + } + }, + + "VkDrmFormatModifierProperties2EXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "drmFormatModifier": {"$ref": "#/definitions/uint64_t"}, + "drmFormatModifierPlaneCount": {"$ref": "#/definitions/uint32_t"}, + "drmFormatModifierTilingFeatures": {"$ref": "#/definitions/VkFormatFeatureFlags2KHR"} + } + }, + + "VkDrmFormatModifierPropertiesList2EXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "drmFormatModifierCount": {"$ref": "#/definitions/uint32_t"}, + "pDrmFormatModifierProperties": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkDrmFormatModifierProperties2EXT"}}]} + } + }, + + "VkPhysicalDeviceImageViewImageFormatInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "imageViewType": {"$ref": "#/definitions/VkImageViewType"} + } + }, + + "VkFilterCubicImageViewImageFormatPropertiesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "filterCubic": {"$ref": "#/definitions/VkBool32"}, + "filterCubicMinmax": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkQueueGlobalPriorityEXT": {"$ref": "#/definitions/enum"}, + "VkDeviceQueueGlobalPriorityCreateInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "globalPriority": {"$ref": "#/definitions/VkQueueGlobalPriorityEXT"} + } + }, + + "VkImportMemoryHostPointerInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "handleType": {"$ref": "#/definitions/VkExternalMemoryHandleTypeFlagBits"}, + "pHostPointer": {"oneOf": [{"$ref": "#/definitions/void"},{"$ref": "#/definitions/void"}]} + } + }, + + "VkMemoryHostPointerPropertiesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "memoryTypeBits": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkPhysicalDeviceExternalMemoryHostPropertiesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "minImportedHostPointerAlignment": {"$ref": "#/definitions/VkDeviceSize"} + } + }, + + "VkTimeDomainEXT": {"$ref": "#/definitions/enum"}, + "VkCalibratedTimestampInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "timeDomain": {"$ref": "#/definitions/VkTimeDomainEXT"} + } + }, + + "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "maxVertexAttribDivisor": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkVertexInputBindingDivisorDescriptionEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "binding": {"$ref": "#/definitions/uint32_t"}, + "divisor": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkPipelineVertexInputDivisorStateCreateInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "vertexBindingDivisorCount": {"$ref": "#/definitions/uint32_t"}, + "pVertexBindingDivisors": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkVertexInputBindingDivisorDescriptionEXT"}}]} + } + }, + + "VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "vertexAttributeInstanceRateDivisor": {"$ref": "#/definitions/VkBool32"}, + "vertexAttributeInstanceRateZeroDivisor": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDevicePCIBusInfoPropertiesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "pciDomain": {"$ref": "#/definitions/uint32_t"}, + "pciBus": {"$ref": "#/definitions/uint32_t"}, + "pciDevice": {"$ref": "#/definitions/uint32_t"}, + "pciFunction": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkPhysicalDeviceSubgroupSizeControlFeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "subgroupSizeControl": {"$ref": "#/definitions/VkBool32"}, + "computeFullSubgroups": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceSubgroupSizeControlPropertiesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "minSubgroupSize": {"$ref": "#/definitions/uint32_t"}, + "maxSubgroupSize": {"$ref": "#/definitions/uint32_t"}, + "maxComputeWorkgroupSubgroups": {"$ref": "#/definitions/uint32_t"}, + "requiredSubgroupSizeStages": {"$ref": "#/definitions/VkShaderStageFlags"} + } + }, + + "VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "requiredSubgroupSize": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "shaderImageInt64Atomics": {"$ref": "#/definitions/VkBool32"}, + "sparseImageInt64Atomics": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceMemoryBudgetPropertiesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "heapBudget": {"$ref": "#/definitions/VkDeviceSize"}, + "heapUsage": {"$ref": "#/definitions/VkDeviceSize"} + } + }, + + "VkValidationFeatureEnableEXT": {"$ref": "#/definitions/enum"}, + "VkValidationFeatureDisableEXT": {"$ref": "#/definitions/enum"}, + "VkValidationFeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "enabledValidationFeatureCount": {"$ref": "#/definitions/uint32_t"}, + "pEnabledValidationFeatures": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkValidationFeatureEnableEXT"}}]}, + "disabledValidationFeatureCount": {"$ref": "#/definitions/uint32_t"}, + "pDisabledValidationFeatures": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkValidationFeatureDisableEXT"}}]} + } + }, + + "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "fragmentShaderSampleInterlock": {"$ref": "#/definitions/VkBool32"}, + "fragmentShaderPixelInterlock": {"$ref": "#/definitions/VkBool32"}, + "fragmentShaderShadingRateInterlock": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "ycbcrImageArrays": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkHeadlessSurfaceCreateFlagsEXT": {"$ref": "#/definitions/VkFlags"}, + "VkHeadlessSurfaceCreateInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "flags": {"$ref": "#/definitions/VkHeadlessSurfaceCreateFlagsEXT"} + } + }, + + "VkLineRasterizationModeEXT": {"$ref": "#/definitions/enum"}, + "VkPhysicalDeviceLineRasterizationFeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "rectangularLines": {"$ref": "#/definitions/VkBool32"}, + "bresenhamLines": {"$ref": "#/definitions/VkBool32"}, + "smoothLines": {"$ref": "#/definitions/VkBool32"}, + "stippledRectangularLines": {"$ref": "#/definitions/VkBool32"}, + "stippledBresenhamLines": {"$ref": "#/definitions/VkBool32"}, + "stippledSmoothLines": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceLineRasterizationPropertiesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "lineSubPixelPrecisionBits": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkPipelineRasterizationLineStateCreateInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "lineRasterizationMode": {"$ref": "#/definitions/VkLineRasterizationModeEXT"}, + "stippledLineEnable": {"$ref": "#/definitions/VkBool32"}, + "lineStippleFactor": {"$ref": "#/definitions/uint32_t"}, + "lineStipplePattern": {"$ref": "#/definitions/uint16_t"} + } + }, + + "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "shaderBufferFloat32Atomics": {"$ref": "#/definitions/VkBool32"}, + "shaderBufferFloat32AtomicAdd": {"$ref": "#/definitions/VkBool32"}, + "shaderBufferFloat64Atomics": {"$ref": "#/definitions/VkBool32"}, + "shaderBufferFloat64AtomicAdd": {"$ref": "#/definitions/VkBool32"}, + "shaderSharedFloat32Atomics": {"$ref": "#/definitions/VkBool32"}, + "shaderSharedFloat32AtomicAdd": {"$ref": "#/definitions/VkBool32"}, + "shaderSharedFloat64Atomics": {"$ref": "#/definitions/VkBool32"}, + "shaderSharedFloat64AtomicAdd": {"$ref": "#/definitions/VkBool32"}, + "shaderImageFloat32Atomics": {"$ref": "#/definitions/VkBool32"}, + "shaderImageFloat32AtomicAdd": {"$ref": "#/definitions/VkBool32"}, + "sparseImageFloat32Atomics": {"$ref": "#/definitions/VkBool32"}, + "sparseImageFloat32AtomicAdd": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceIndexTypeUint8FeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "indexTypeUint8": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "extendedDynamicState": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "shaderDemoteToHelperInvocation": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "texelBufferAlignment": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "storageTexelBufferOffsetAlignmentBytes": {"$ref": "#/definitions/VkDeviceSize"}, + "storageTexelBufferOffsetSingleTexelAlignment": {"$ref": "#/definitions/VkBool32"}, + "uniformTexelBufferOffsetAlignmentBytes": {"$ref": "#/definitions/VkDeviceSize"}, + "uniformTexelBufferOffsetSingleTexelAlignment": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceRobustness2FeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "robustBufferAccess2": {"$ref": "#/definitions/VkBool32"}, + "robustImageAccess2": {"$ref": "#/definitions/VkBool32"}, + "nullDescriptor": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceRobustness2PropertiesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "robustStorageBufferAccessSizeAlignment": {"$ref": "#/definitions/VkDeviceSize"}, + "robustUniformBufferAccessSizeAlignment": {"$ref": "#/definitions/VkDeviceSize"} + } + }, + + "VkSamplerCustomBorderColorCreateInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "customBorderColor": {"$ref": "#/definitions/VkClearColorValue"}, + "format": {"$ref": "#/definitions/VkFormat"} + } + }, + + "VkPhysicalDeviceCustomBorderColorPropertiesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "maxCustomBorderColorSamplers": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkPhysicalDeviceCustomBorderColorFeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "customBorderColors": {"$ref": "#/definitions/VkBool32"}, + "customBorderColorWithoutFormat": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "ycbcr2plane444Formats": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceImageRobustnessFeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "robustImageAccess": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDevice4444FormatsFeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "formatA4R4G4B4": {"$ref": "#/definitions/VkBool32"}, + "formatA4B4G4R4": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "vertexInputDynamicState": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkVertexInputBindingDescription2EXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "binding": {"$ref": "#/definitions/uint32_t"}, + "stride": {"$ref": "#/definitions/uint32_t"}, + "inputRate": {"$ref": "#/definitions/VkVertexInputRate"}, + "divisor": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkVertexInputAttributeDescription2EXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "location": {"$ref": "#/definitions/uint32_t"}, + "binding": {"$ref": "#/definitions/uint32_t"}, + "format": {"$ref": "#/definitions/VkFormat"}, + "offset": {"$ref": "#/definitions/uint32_t"} + } + }, + + "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "extendedDynamicState2": {"$ref": "#/definitions/VkBool32"}, + "extendedDynamicState2LogicOp": {"$ref": "#/definitions/VkBool32"}, + "extendedDynamicState2PatchControlPoints": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPhysicalDeviceColorWriteEnableFeaturesEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "colorWriteEnable": {"$ref": "#/definitions/VkBool32"} + } + }, + + "VkPipelineColorWriteCreateInfoEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "attachmentCount": {"$ref": "#/definitions/uint32_t"}, + "pColorWriteEnables": {"oneOf": [{"$ref": "#/definitions/void"}, {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/VkBool32"}}]} + } + }, + + "VkApplicationParametersEXT": { + "type": "object", + "additionalProperties": false, + "properties": { + "sType": {"$ref": "#/definitions/VkStructureType"}, + "pNext": {"$ref": "#/definitions/void"}, + "vendorID": {"$ref": "#/definitions/uint32_t"}, + "deviceID": {"$ref": "#/definitions/uint32_t"}, + "key": {"$ref": "#/definitions/uint32_t"}, + "value": {"$ref": "#/definitions/uint64_t"} + } + }, + + "VkLastStructure": { + } + } +} diff --git a/json/vkpcc.json b/json/vkpcc.json new file mode 100644 index 0000000..3e4c8b5 --- /dev/null +++ b/json/vkpcc.json @@ -0,0 +1,60 @@ +{ +"$schema": "http://json-schema.org/draft-04/schema#", +"id": "https://schema.khronos.org/vulkan/vkpcc.json#", +"title": "JSON schema for Vulkan pipeline state", +"description": "Schema for representing Vulkan pipeline state for use with the offline Pipeline Cache Compiler.", +"type": "object", +"additionalProperties": true, + +"definitions": { + "ShaderInfo" : { + "stage" : {"type": "string", "format": "uri"}, + "filename" : {"type": "string", "format": "uri"} + }, + + "GraphicsPipelineState": { + "type": "object", + "additionalProperties": false, + "properties": { + "Renderpass": {"$ref": "https://schema.khronos.org/vulkan/vk.json#/definitions/VkRenderPassCreateInfo"}, + "Renderpass2": {"$ref": "https://schema.khronos.org/vulkan/vk.json#/definitions/VkRenderPassCreateInfo2"}, + "YcbcrSamplers": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"type": "object", "patternProperties": {"^\\w+$": {"$ref": "https://schema.khronos.org/vulkan/vk.json#/definitions/VkSamplerYcbcrConversionCreateInfo"}}}}, + "ImmutableSamplers": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"type": "object", "patternProperties": {"^\\w+$": {"$ref": "https://schema.khronos.org/vulkan/vk.json#/definitions/VkSamplerCreateInfo"}}}}, + "DescriptorSetLayouts": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"type": "object", "patternProperties": {"^\\w+$": {"$ref": "https://schema.khronos.org/vulkan/vk.json#/definitions/VkDescriptorSetLayoutCreateInfo"}}}}, + "PipelineLayout": {"$ref": "https://schema.khronos.org/vulkan/vk.json#/definitions/VkPipelineLayoutCreateInfo"}, + "GraphicsPipeline": {"$ref": "https://schema.khronos.org/vulkan/vk.json#/definitions/VkGraphicsPipelineCreateInfo"}, + "ShaderFileNames": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"$ref": "#/definitions/ShaderInfo"}}, + "PhysicalDeviceFeatures": {"$ref": "https://schema.khronos.org/vulkan/vk.json#/definitions/VkPhysicalDeviceFeatures2"} + }, + "oneOf" : [{"required" : ["Renderpass"]}, {"required" : ["Renderpass2"]}], + "required" : ["PipelineLayout", "GraphicsPipeline", "ShaderFileNames"] + }, + + "ComputePipelineState": { + "type": "object", + "additionalProperties": false, + "properties": { + "YcbcrSamplers": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"type": "object", "patternProperties": {"^\\w+$": {"$ref": "https://schema.khronos.org/vulkan/vk.json#/definitions/VkSamplerYcbcrConversionCreateInfo"}}}}, + "ImmutableSamplers": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"type": "object", "patternProperties": {"^\\w+$": {"$ref": "https://schema.khronos.org/vulkan/vk.json#/definitions/VkSamplerCreateInfo"}}}}, + "DescriptorSetLayouts": {"type": "array", "minItems": 0, "maxItems": 255, "items": {"type": "object", "patternProperties": {"^\\w+$": {"$ref": "https://schema.khronos.org/vulkan/vk.json#/definitions/VkDescriptorSetLayoutCreateInfo"}}}}, + "PipelineLayout": {"$ref": "https://schema.khronos.org/vulkan/vk.json#/definitions/VkPipelineLayoutCreateInfo"}, + "ComputePipeline": {"$ref": "https://schema.khronos.org/vulkan/vk.json#/definitions/VkComputePipelineCreateInfo"}, + "ShaderFileNames": {"$ref": "#/definitions/ShaderInfo"}, + "PhysicalDeviceFeatures": {"$ref": "https://schema.khronos.org/vulkan/vk.json#/definitions/VkPhysicalDeviceFeatures2"} + }, + "required" : ["PipelineLayout", "ComputePipeline", "ShaderFileNames"] + } +}, + +"properties": { + "GraphicsPipelineState" : {"$ref": "#/definitions/GraphicsPipelineState"}, + "ComputePipelineState" : {"$ref": "#/definitions/ComputePipelineState"}, + "PipelineUUID" : {"type": "array", "minItems": 16, "maxItems": 16, "items": {"$ref": "https://schema.khronos.org/vulkan/vk.json#/definitions/uint8_t"}}, + "DeviceExtensions" : {"type": "array", "items": {"type": "string", "format": "uri"}} +}, + +"anyOf": [ + {"required": ["GraphicsPipelineState"]}, + {"required": ["ComputePipelineState"]} +] +} diff --git a/json/vulkan_json_data.hpp b/json/vulkan_json_data.hpp new file mode 100644 index 0000000..a3fb85e --- /dev/null +++ b/json/vulkan_json_data.hpp @@ -0,0 +1,36108 @@ +#ifndef _VULKAN_JSON_DATA_HPP +#define _VULKAN_JSON_DATA_HPP + +/* + * Copyright (c) 2021 The Khronos Group Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + *//*! + * \file + * \brief Defines JSON generators for Vulkan structures + */ + + +/********************************************************************************************/ +/** This code is generated. To make changes, please modify the scripts or the relevant xml **/ +/********************************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#ifndef VULKAN_JSON_CTS + #include +#endif + +#ifdef _WIN32 + #ifndef WIN32_LEAN_AND_MEAN + #define WIN32_LEAN_AND_MEAN + #endif + #define VC_EXTRALEAN + #define NOMINMAX + #include +#endif + +namespace vk_json { + +static thread_local int s_num_spaces = 0; +#if defined(USE_THREAD_LOCAL_WAR) +// Workaround (off by default) for certain platforms that have a thread_local libc bug +std::stringstream & TLSGetStrStream(); +#define _string_stream TLSGetStrStream() +#else +static thread_local std::stringstream _string_stream; +#endif + +static void dumpPNextChain(const void* pNext); + +// By default, redirect to std::cout. Can stream it to a stringstream if needed. +//#define _OUT std::cout +#define _OUT _string_stream + +// Helper utility to do indentation in the generated json file. +#define PRINT_SPACE for (int k = 0; k < s_num_spaces; k++) _OUT << " "; + +#define INDENT(sz) s_num_spaces += (sz); + +#define PRINT_VAL(c) PRINT_SPACE \ + if (s != "") {\ + _OUT << "\"" << s << "\"" << " : " << o << (c ? "," : "") << std::endl; \ + } else {\ + _OUT << o << (c ? "," : "") << std::endl; \ + } + +#define PRINT_STR(c) PRINT_SPACE \ + if (s != "") {\ + _OUT << "\"" << s << "\"" << " : " << "\"" << o << "\"" << (c ? "," : "") << std::endl; \ + } else {\ + _OUT << "\"" << o << "\"" << (c ? "," : "") << std::endl; \ + } + +// To make sure the generated data is consistent across platforms, +// we typecast to 32-bit and dump the data. +// The value is not expected to exceed the range. +static void print_size_t(const size_t* o, const std::string& s, bool commaNeeded=true) +{ + PRINT_SPACE + _OUT << "\"" << s << "\"" << " : " << static_cast(*o) << (commaNeeded ? "," : "") << std::endl;\ +} +static void print_size_t(size_t o, const std::string& s, bool commaNeeded=true) +{ + PRINT_SPACE + _OUT << "\"" << s << "\"" << " : " << static_cast(o) << (commaNeeded ? "," : "") << std::endl;\ +} + +static void print_int32_t(int32_t o, const std::string& s, bool commaNeeded=true) +{ + PRINT_VAL(commaNeeded) +} + +static void print_int32_t(const int32_t * o, const std::string& s, bool commaNeeded=true) +{ + PRINT_VAL(commaNeeded) +} + +static void print_uint32_t(uint32_t o, const std::string& s, bool commaNeeded=true) +{ + PRINT_VAL(commaNeeded) +} + +static void print_uint32_t(const uint32_t * o, const std::string& s, bool commaNeeded=true) +{ + PRINT_VAL(commaNeeded) +} + +static void print_uint8_t(uint8_t o, const std::string& s, bool commaNeeded=true) +{ + PRINT_VAL(commaNeeded) +} + +static void print_uint8_t(const uint8_t * o, const std::string& s, bool commaNeeded=true) +{ + PRINT_VAL(commaNeeded) +} + +static void print_uint64_t(uint64_t o, const std::string& s, bool commaNeeded=true) +{ + PRINT_VAL(commaNeeded) +} + +static void print_uint64_t(const uint64_t * o, const std::string& s, bool commaNeeded=true) +{ + PRINT_VAL(commaNeeded) +} + +static void print_float(float o, const std::string& s, bool commaNeeded=true) +{ + PRINT_VAL(commaNeeded) +} + +static void print_float(const float * o, const std::string& s, bool commaNeeded=true) +{ + PRINT_VAL(commaNeeded) +} + +static void print_int(int o, const std::string& s, bool commaNeeded=true) +{ + PRINT_VAL(commaNeeded) +} + +static void print_int(const int * o, const std::string& s, bool commaNeeded=true) +{ + PRINT_VAL(commaNeeded) +} + +static void print_double(double o, const std::string& s, bool commaNeeded=true) +{ + PRINT_VAL(commaNeeded) +} + +static void print_double(const double * o, const std::string& s, bool commaNeeded=true) +{ + PRINT_VAL(commaNeeded) +} + +static void print_int64_t(int64_t o, const std::string& s, bool commaNeeded=true) +{ + PRINT_VAL(commaNeeded) +} + +static void print_int64_t(const int64_t * o, const std::string& s, bool commaNeeded=true) +{ + PRINT_VAL(commaNeeded) +} + +static void print_uint16_t(uint16_t o, const std::string& s, bool commaNeeded=true) +{ + PRINT_VAL(commaNeeded) +} + +static void print_uint16_t(const uint16_t * o, const std::string& s, bool commaNeeded=true) +{ + PRINT_VAL(commaNeeded) +} + +static void print_char(const char * const* o, const std::string& s, bool commaNeeded=true) +{ + PRINT_STR(commaNeeded) +} + +static void print_char(char o, const std::string& s, bool commaNeeded=true) +{ + PRINT_VAL(commaNeeded) +} + +static void print_char(const char * o, const std::string& s, bool commaNeeded=true) +{ + PRINT_STR(commaNeeded) +} + + +// Base 64 formater class from executor/xeTestLogWriter.cpp + +class Base64Formatter +{ +public: + const uint8_t* data; + int numBytes; + + Base64Formatter(const uint8_t* data_, int numBytes_) : data(data_), numBytes(numBytes_) {} +}; + +std::ostream& operator<< (std::ostream& str, const Base64Formatter& fmt) +{ + static const char s_base64Table[64] = + { + 'A','B','C','D','E','F','G','H','I','J','K','L','M', + 'N','O','P','Q','R','S','T','U','V','W','X','Y','Z', + 'a','b','c','d','e','f','g','h','i','j','k','l','m', + 'n','o','p','q','r','s','t','u','v','w','x','y','z', + '0','1','2','3','4','5','6','7','8','9','+','/' + }; + + const uint8_t* data = fmt.data; + int numBytes = fmt.numBytes; + int srcNdx = 0; + + assert(data && (numBytes > 0)); + + /* Loop all input chars. */ + while (srcNdx < numBytes) + { + #undef min + int numRead = std::min(3, numBytes - srcNdx); + uint8_t s0 = data[srcNdx]; + uint8_t s1 = (numRead >= 2) ? data[srcNdx + 1] : 0; + uint8_t s2 = (numRead >= 3) ? data[srcNdx + 2] : 0; + char d[4]; + + srcNdx += numRead; + + d[0] = s_base64Table[s0 >> 2]; + d[1] = s_base64Table[((s0 & 0x3) << 4) | (s1 >> 4)]; + d[2] = s_base64Table[((s1 & 0xF) << 2) | (s2 >> 6)]; + d[3] = s_base64Table[s2 & 0x3F]; + + if (numRead < 3) d[3] = '='; + if (numRead < 2) d[2] = '='; + + /* Write data. */ + str.write(&d[0], sizeof(d)); + } + + return str; +} + +inline Base64Formatter toBase64(const uint8_t* bytes, int numBytes) {return Base64Formatter(bytes, numBytes); } + +static void print_void_data(const void * o, int oSize, const std::string& s, bool commaNeeded=true) +{ + if (o != NULL && oSize != 0) + { + PRINT_SPACE _OUT << "\"" << s << "\"" << " : " << "\"" << toBase64((uint8_t*)o, oSize) << "\"" << (commaNeeded ? "," : "") << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"" << s << "\"" << " : " << "\"NULL\"" << (commaNeeded ? "," : "") << std::endl; + } +} + +static void print_VkBool32(VkBool32 obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "\"" << str << "\"" << " : " << "\"" << ((obj == 0) ? ("VK_FALSE") : ("VK_TRUE")) << "\"" << (commaNeeded ? "," : "") << std::endl; +} +static void print_VkBool32(const VkBool32 * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "\"" << str << "\"" << " : " << "\"" << ((obj == 0) ? ("VK_FALSE") : ("VK_TRUE")) << "\"" << (commaNeeded ? "," : "") << std::endl; +} + +static void print_VkDeviceAddress(VkDeviceAddress obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl; +} +static void print_VkDeviceAddress(const VkDeviceAddress * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl; +} + +static void print_VkDeviceSize(VkDeviceSize obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl; +} +static void print_VkDeviceSize(const VkDeviceSize * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl; +} + +static void print_VkFlags(VkFlags obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl; +} +static void print_VkFlags(const VkFlags * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl; +} + +static void print_VkSampleMask(VkSampleMask obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl; +} +static void print_VkSampleMask(const VkSampleMask * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl; +} + +static void print_VkBuffer(VkBuffer obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkBuffer(const VkBuffer * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkImage(VkImage obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkImage(const VkImage * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkInstance(VkInstance obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkInstance(const VkInstance * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkPhysicalDevice(VkPhysicalDevice obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkPhysicalDevice(const VkPhysicalDevice * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkDevice(VkDevice obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkDevice(const VkDevice * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkQueue(VkQueue obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkQueue(const VkQueue * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkSemaphore(VkSemaphore obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkSemaphore(const VkSemaphore * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkCommandBuffer(VkCommandBuffer obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkCommandBuffer(const VkCommandBuffer * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkFence(VkFence obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkFence(const VkFence * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkDeviceMemory(VkDeviceMemory obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkDeviceMemory(const VkDeviceMemory * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkEvent(VkEvent obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkEvent(const VkEvent * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkQueryPool(VkQueryPool obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkQueryPool(const VkQueryPool * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkBufferView(VkBufferView obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkBufferView(const VkBufferView * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkImageView(VkImageView obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkImageView(const VkImageView * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkShaderModule(VkShaderModule obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkShaderModule(const VkShaderModule * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkPipelineCache(VkPipelineCache obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkPipelineCache(const VkPipelineCache * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkPipelineLayout(VkPipelineLayout obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkPipelineLayout(const VkPipelineLayout * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkPipeline(VkPipeline obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkPipeline(const VkPipeline * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkRenderPass(VkRenderPass obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkRenderPass(const VkRenderPass * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkDescriptorSetLayout(VkDescriptorSetLayout obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkDescriptorSetLayout(const VkDescriptorSetLayout * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkSampler(VkSampler obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkSampler(const VkSampler * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkDescriptorSet(VkDescriptorSet obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkDescriptorSet(const VkDescriptorSet * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkDescriptorPool(VkDescriptorPool obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkDescriptorPool(const VkDescriptorPool * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkFramebuffer(VkFramebuffer obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkFramebuffer(const VkFramebuffer * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkCommandPool(VkCommandPool obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkCommandPool(const VkCommandPool * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static std::map VkResult_map = { + std::make_pair(0, "VK_SUCCESS"), + std::make_pair(1, "VK_NOT_READY"), + std::make_pair(2, "VK_TIMEOUT"), + std::make_pair(3, "VK_EVENT_SET"), + std::make_pair(4, "VK_EVENT_RESET"), + std::make_pair(5, "VK_INCOMPLETE"), + std::make_pair(-1, "VK_ERROR_OUT_OF_HOST_MEMORY"), + std::make_pair(-2, "VK_ERROR_OUT_OF_DEVICE_MEMORY"), + std::make_pair(-3, "VK_ERROR_INITIALIZATION_FAILED"), + std::make_pair(-4, "VK_ERROR_DEVICE_LOST"), + std::make_pair(-5, "VK_ERROR_MEMORY_MAP_FAILED"), + std::make_pair(-6, "VK_ERROR_LAYER_NOT_PRESENT"), + std::make_pair(-7, "VK_ERROR_EXTENSION_NOT_PRESENT"), + std::make_pair(-8, "VK_ERROR_FEATURE_NOT_PRESENT"), + std::make_pair(-9, "VK_ERROR_INCOMPATIBLE_DRIVER"), + std::make_pair(-10, "VK_ERROR_TOO_MANY_OBJECTS"), + std::make_pair(-11, "VK_ERROR_FORMAT_NOT_SUPPORTED"), + std::make_pair(-12, "VK_ERROR_FRAGMENTED_POOL"), + std::make_pair(-13, "VK_ERROR_UNKNOWN"), + std::make_pair(1000069000, "VK_ERROR_OUT_OF_POOL_MEMORY"), + std::make_pair(1000072003, "VK_ERROR_INVALID_EXTERNAL_HANDLE"), + std::make_pair(1000161000, "VK_ERROR_FRAGMENTATION"), + std::make_pair(1000257000, "VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS"), + std::make_pair(1000011001, "VK_ERROR_VALIDATION_FAILED"), + std::make_pair(1000298000, "VK_ERROR_INVALID_PIPELINE_CACHE_DATA"), + std::make_pair(1000298001, "VK_ERROR_NO_PIPELINE_MATCH"), + std::make_pair(1000000000, "VK_ERROR_SURFACE_LOST_KHR"), + std::make_pair(1000000001, "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR"), + std::make_pair(1000001003, "VK_SUBOPTIMAL_KHR"), + std::make_pair(1000001004, "VK_ERROR_OUT_OF_DATE_KHR"), + std::make_pair(1000003001, "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR"), + std::make_pair(1000012000, "VK_ERROR_INVALID_SHADER_NV"), + std::make_pair(1000158000, "VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT"), + std::make_pair(1000174001, "VK_ERROR_NOT_PERMITTED_EXT"), + std::make_pair(1000255000, "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT"), + std::make_pair(1000268000, "VK_THREAD_IDLE_KHR"), + std::make_pair(1000268001, "VK_THREAD_DONE_KHR"), + std::make_pair(1000268002, "VK_OPERATION_DEFERRED_KHR"), + std::make_pair(1000268003, "VK_OPERATION_NOT_DEFERRED_KHR"), + std::make_pair(1000297000, "VK_PIPELINE_COMPILE_REQUIRED_EXT"), +}; +static void print_VkResult(VkResult obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkResult_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkResult_map[obj] << "\"" << std::endl; +} +static void print_VkResult(const VkResult * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkResult_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkResult_map[*obj] << "\"" << std::endl; +} + +static std::map VkStructureType_map = { + std::make_pair(0, "VK_STRUCTURE_TYPE_APPLICATION_INFO"), + std::make_pair(1, "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO"), + std::make_pair(2, "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO"), + std::make_pair(3, "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO"), + std::make_pair(4, "VK_STRUCTURE_TYPE_SUBMIT_INFO"), + std::make_pair(5, "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO"), + std::make_pair(6, "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE"), + std::make_pair(8, "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO"), + std::make_pair(9, "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO"), + std::make_pair(10, "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO"), + std::make_pair(11, "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO"), + std::make_pair(12, "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO"), + std::make_pair(13, "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO"), + std::make_pair(14, "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO"), + std::make_pair(15, "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO"), + std::make_pair(17, "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO"), + std::make_pair(18, "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO"), + std::make_pair(19, "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO"), + std::make_pair(20, "VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO"), + std::make_pair(21, "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO"), + std::make_pair(22, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO"), + std::make_pair(23, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO"), + std::make_pair(24, "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO"), + std::make_pair(25, "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO"), + std::make_pair(26, "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO"), + std::make_pair(27, "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO"), + std::make_pair(28, "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO"), + std::make_pair(29, "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO"), + std::make_pair(30, "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO"), + std::make_pair(31, "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO"), + std::make_pair(32, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO"), + std::make_pair(33, "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO"), + std::make_pair(34, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO"), + std::make_pair(35, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET"), + std::make_pair(36, "VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET"), + std::make_pair(37, "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO"), + std::make_pair(38, "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO"), + std::make_pair(39, "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO"), + std::make_pair(40, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO"), + std::make_pair(41, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO"), + std::make_pair(42, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO"), + std::make_pair(43, "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO"), + std::make_pair(44, "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER"), + std::make_pair(45, "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER"), + std::make_pair(46, "VK_STRUCTURE_TYPE_MEMORY_BARRIER"), + std::make_pair(47, "VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO"), + std::make_pair(48, "VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO"), + std::make_pair(1000094000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES"), + std::make_pair(1000157000, "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO"), + std::make_pair(1000157001, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO"), + std::make_pair(1000083000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES"), + std::make_pair(1000127000, "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS"), + std::make_pair(1000127001, "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO"), + std::make_pair(1000060000, "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO"), + std::make_pair(1000060003, "VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO"), + std::make_pair(1000060004, "VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO"), + std::make_pair(1000060005, "VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO"), + std::make_pair(1000060013, "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO"), + std::make_pair(1000060014, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO"), + std::make_pair(1000070000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES"), + std::make_pair(1000070001, "VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO"), + std::make_pair(1000146000, "VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2"), + std::make_pair(1000146001, "VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2"), + std::make_pair(1000146003, "VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2"), + std::make_pair(1000059000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2"), + std::make_pair(1000059001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2"), + std::make_pair(1000059002, "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2"), + std::make_pair(1000059003, "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2"), + std::make_pair(1000059004, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2"), + std::make_pair(1000059005, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2"), + std::make_pair(1000059006, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2"), + std::make_pair(1000117000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES"), + std::make_pair(1000117001, "VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO"), + std::make_pair(1000117002, "VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO"), + std::make_pair(1000117003, "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO"), + std::make_pair(1000053000, "VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO"), + std::make_pair(1000053001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES"), + std::make_pair(1000053002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES"), + std::make_pair(1000120000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES"), + std::make_pair(1000145000, "VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO"), + std::make_pair(1000145001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES"), + std::make_pair(1000145002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES"), + std::make_pair(1000145003, "VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2"), + std::make_pair(1000156000, "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO"), + std::make_pair(1000156001, "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO"), + std::make_pair(1000156002, "VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO"), + std::make_pair(1000156003, "VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO"), + std::make_pair(1000156004, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES"), + std::make_pair(1000156005, "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES"), + std::make_pair(1000071000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO"), + std::make_pair(1000071001, "VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES"), + std::make_pair(1000071002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO"), + std::make_pair(1000071003, "VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES"), + std::make_pair(1000071004, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES"), + std::make_pair(1000072000, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO"), + std::make_pair(1000072001, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO"), + std::make_pair(1000072002, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO"), + std::make_pair(1000112000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO"), + std::make_pair(1000112001, "VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES"), + std::make_pair(1000113000, "VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO"), + std::make_pair(1000077000, "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO"), + std::make_pair(1000076000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO"), + std::make_pair(1000076001, "VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES"), + std::make_pair(1000168000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES"), + std::make_pair(1000168001, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT"), + std::make_pair(1000063000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES"), + std::make_pair(49, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES"), + std::make_pair(50, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES"), + std::make_pair(51, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES"), + std::make_pair(52, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES"), + std::make_pair(1000147000, "VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO"), + std::make_pair(1000109000, "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2"), + std::make_pair(1000109001, "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2"), + std::make_pair(1000109002, "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2"), + std::make_pair(1000109003, "VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2"), + std::make_pair(1000109004, "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2"), + std::make_pair(1000109005, "VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO"), + std::make_pair(1000109006, "VK_STRUCTURE_TYPE_SUBPASS_END_INFO"), + std::make_pair(1000177000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES"), + std::make_pair(1000196000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES"), + std::make_pair(1000180000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES"), + std::make_pair(1000082000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES"), + std::make_pair(1000197000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES"), + std::make_pair(1000161000, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO"), + std::make_pair(1000161001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES"), + std::make_pair(1000161002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES"), + std::make_pair(1000161003, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO"), + std::make_pair(1000161004, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT"), + std::make_pair(1000199000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES"), + std::make_pair(1000199001, "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE"), + std::make_pair(1000221000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES"), + std::make_pair(1000246000, "VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO"), + std::make_pair(1000130000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES"), + std::make_pair(1000130001, "VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO"), + std::make_pair(1000211000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES"), + std::make_pair(1000108000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES"), + std::make_pair(1000108001, "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO"), + std::make_pair(1000108002, "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO"), + std::make_pair(1000108003, "VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO"), + std::make_pair(1000253000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES"), + std::make_pair(1000175000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES"), + std::make_pair(1000241000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES"), + std::make_pair(1000241001, "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT"), + std::make_pair(1000241002, "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT"), + std::make_pair(1000261000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES"), + std::make_pair(1000207000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES"), + std::make_pair(1000207001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES"), + std::make_pair(1000207002, "VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO"), + std::make_pair(1000207003, "VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO"), + std::make_pair(1000207004, "VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO"), + std::make_pair(1000207005, "VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO"), + std::make_pair(1000257000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES"), + std::make_pair(1000244001, "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO"), + std::make_pair(1000257002, "VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO"), + std::make_pair(1000257003, "VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO"), + std::make_pair(1000257004, "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO"), + std::make_pair(1000298000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES"), + std::make_pair(1000298001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES"), + std::make_pair(1000298002, "VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO"), + std::make_pair(1000298003, "VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO"), + std::make_pair(1000298004, "VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_CONSUMPTION"), + std::make_pair(1000298005, "VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE"), + std::make_pair(1000298007, "VK_STRUCTURE_TYPE_FAULT_DATA"), + std::make_pair(1000298008, "VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO"), + std::make_pair(1000298010, "VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO"), + std::make_pair(1000001000, "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR"), + std::make_pair(1000001001, "VK_STRUCTURE_TYPE_PRESENT_INFO_KHR"), + std::make_pair(1000060007, "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR"), + std::make_pair(1000060008, "VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR"), + std::make_pair(1000060009, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR"), + std::make_pair(1000060010, "VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR"), + std::make_pair(1000060011, "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR"), + std::make_pair(1000060012, "VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR"), + std::make_pair(1000002000, "VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR"), + std::make_pair(1000002001, "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR"), + std::make_pair(1000003000, "VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR"), + std::make_pair(1000004000, "VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR"), + std::make_pair(1000005000, "VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR"), + std::make_pair(1000006000, "VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR"), + std::make_pair(1000008000, "VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR"), + std::make_pair(1000009000, "VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR"), + std::make_pair(1000010000, "VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID"), + std::make_pair(1000010001, "VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID"), + std::make_pair(1000010002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID"), + std::make_pair(1000011000, "VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT"), + std::make_pair(1000018000, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD"), + std::make_pair(1000022000, "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT"), + std::make_pair(1000022001, "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT"), + std::make_pair(1000022002, "VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT"), + std::make_pair(1000023000, "VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR"), + std::make_pair(1000023001, "VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR"), + std::make_pair(1000023002, "VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR"), + std::make_pair(1000023003, "VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR"), + std::make_pair(1000023004, "VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR"), + std::make_pair(1000023005, "VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR"), + std::make_pair(1000023006, "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR"), + std::make_pair(1000023007, "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR"), + std::make_pair(1000023008, "VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR"), + std::make_pair(1000023009, "VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR"), + std::make_pair(1000023010, "VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR"), + std::make_pair(1000023011, "VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR"), + std::make_pair(1000023012, "VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR"), + std::make_pair(1000023013, "VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR"), + std::make_pair(1000023014, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR"), + std::make_pair(1000023015, "VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR"), + std::make_pair(1000024000, "VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR"), + std::make_pair(1000026000, "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV"), + std::make_pair(1000026001, "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV"), + std::make_pair(1000026002, "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV"), + std::make_pair(1000028000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT"), + std::make_pair(1000028001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT"), + std::make_pair(1000028002, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT"), + std::make_pair(1000029000, "VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX"), + std::make_pair(1000029001, "VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX"), + std::make_pair(1000029002, "VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX"), + std::make_pair(1000030000, "VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX"), + std::make_pair(1000030001, "VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX"), + std::make_pair(1000038000, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT"), + std::make_pair(1000038001, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT"), + std::make_pair(1000038002, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT"), + std::make_pair(1000038003, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT"), + std::make_pair(1000038004, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT"), + std::make_pair(1000038005, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT"), + std::make_pair(1000038006, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT"), + std::make_pair(1000038007, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT"), + std::make_pair(1000038008, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT"), + std::make_pair(1000038009, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT"), + std::make_pair(1000038010, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT"), + std::make_pair(1000039000, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT"), + std::make_pair(1000039001, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT"), + std::make_pair(1000039002, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT"), + std::make_pair(1000039003, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT"), + std::make_pair(1000039004, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT"), + std::make_pair(1000039005, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT"), + std::make_pair(1000039006, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_EXT"), + std::make_pair(1000039007, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT"), + std::make_pair(1000039008, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT"), + std::make_pair(1000039009, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT"), + std::make_pair(1000039010, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT"), + std::make_pair(1000039011, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT"), + std::make_pair(1000040000, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT"), + std::make_pair(1000040001, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT"), + std::make_pair(1000040002, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT"), + std::make_pair(1000040003, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT"), + std::make_pair(1000040004, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT"), + std::make_pair(1000040005, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT"), + std::make_pair(1000040006, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT"), + std::make_pair(1000040007, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT"), + std::make_pair(1000041000, "VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD"), + std::make_pair(1000044000, "VK_STRUCTURE_TYPE_RENDERING_INFO_KHR"), + std::make_pair(1000044001, "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR"), + std::make_pair(1000044002, "VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR"), + std::make_pair(1000044003, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR"), + std::make_pair(1000044004, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR"), + std::make_pair(1000044006, "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR"), + std::make_pair(1000044007, "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT"), + std::make_pair(1000044008, "VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD"), + std::make_pair(1000044009, "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX"), + std::make_pair(1000049000, "VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP"), + std::make_pair(1000050000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV"), + std::make_pair(1000056000, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV"), + std::make_pair(1000056001, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV"), + std::make_pair(1000057000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV"), + std::make_pair(1000057001, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV"), + std::make_pair(1000058000, "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV"), + std::make_pair(1000060007, "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR"), + std::make_pair(1000060008, "VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR"), + std::make_pair(1000060009, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR"), + std::make_pair(1000060010, "VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR"), + std::make_pair(1000060011, "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR"), + std::make_pair(1000060012, "VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR"), + std::make_pair(1000061000, "VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT"), + std::make_pair(1000062000, "VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN"), + std::make_pair(1000066000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT"), + std::make_pair(1000067000, "VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT"), + std::make_pair(1000067001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT"), + std::make_pair(1000073000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR"), + std::make_pair(1000073001, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR"), + std::make_pair(1000073002, "VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR"), + std::make_pair(1000073003, "VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR"), + std::make_pair(1000074000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR"), + std::make_pair(1000074001, "VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR"), + std::make_pair(1000074002, "VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR"), + std::make_pair(1000075000, "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR"), + std::make_pair(1000078000, "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR"), + std::make_pair(1000078001, "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR"), + std::make_pair(1000078002, "VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR"), + std::make_pair(1000078003, "VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR"), + std::make_pair(1000079000, "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR"), + std::make_pair(1000079001, "VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR"), + std::make_pair(1000080000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR"), + std::make_pair(1000081000, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT"), + std::make_pair(1000081001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT"), + std::make_pair(1000081002, "VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT"), + std::make_pair(1000084000, "VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR"), + std::make_pair(1000087000, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV"), + std::make_pair(1000090000, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT"), + std::make_pair(1000091000, "VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT"), + std::make_pair(1000091001, "VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT"), + std::make_pair(1000091002, "VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT"), + std::make_pair(1000091003, "VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT"), + std::make_pair(1000092000, "VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE"), + std::make_pair(1000097000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX"), + std::make_pair(1000098000, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV"), + std::make_pair(1000099000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT"), + std::make_pair(1000099001, "VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT"), + std::make_pair(1000101000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT"), + std::make_pair(1000101001, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT"), + std::make_pair(1000102000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT"), + std::make_pair(1000102001, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT"), + std::make_pair(1000105000, "VK_STRUCTURE_TYPE_HDR_METADATA_EXT"), + std::make_pair(1000111000, "VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR"), + std::make_pair(1000114000, "VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR"), + std::make_pair(1000114001, "VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR"), + std::make_pair(1000114002, "VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR"), + std::make_pair(1000115000, "VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR"), + std::make_pair(1000115001, "VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR"), + std::make_pair(1000116000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR"), + std::make_pair(1000116001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR"), + std::make_pair(1000116002, "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR"), + std::make_pair(1000116003, "VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR"), + std::make_pair(1000116004, "VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR"), + std::make_pair(1000116005, "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR"), + std::make_pair(1000116006, "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR"), + std::make_pair(1000116007, "VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR"), + std::make_pair(1000119000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR"), + std::make_pair(1000119001, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR"), + std::make_pair(1000119002, "VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR"), + std::make_pair(1000121000, "VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR"), + std::make_pair(1000121001, "VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR"), + std::make_pair(1000121002, "VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR"), + std::make_pair(1000121003, "VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR"), + std::make_pair(1000121004, "VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR"), + std::make_pair(1000122000, "VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK"), + std::make_pair(1000123000, "VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK"), + std::make_pair(1000128000, "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT"), + std::make_pair(1000128001, "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT"), + std::make_pair(1000128002, "VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT"), + std::make_pair(1000128003, "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT"), + std::make_pair(1000128004, "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT"), + std::make_pair(1000129000, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID"), + std::make_pair(1000129001, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID"), + std::make_pair(1000129002, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID"), + std::make_pair(1000129003, "VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID"), + std::make_pair(1000129004, "VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID"), + std::make_pair(1000129005, "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID"), + std::make_pair(1000129006, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID"), + std::make_pair(1000138000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT"), + std::make_pair(1000138001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT"), + std::make_pair(1000138002, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT"), + std::make_pair(1000138003, "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT"), + std::make_pair(1000143000, "VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT"), + std::make_pair(1000143001, "VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT"), + std::make_pair(1000143002, "VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT"), + std::make_pair(1000143003, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT"), + std::make_pair(1000143004, "VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT"), + std::make_pair(1000148000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT"), + std::make_pair(1000148001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT"), + std::make_pair(1000148002, "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT"), + std::make_pair(1000149000, "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV"), + std::make_pair(1000150007, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR"), + std::make_pair(1000150000, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR"), + std::make_pair(1000150002, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR"), + std::make_pair(1000150003, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR"), + std::make_pair(1000150004, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR"), + std::make_pair(1000150005, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR"), + std::make_pair(1000150006, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR"), + std::make_pair(1000150009, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR"), + std::make_pair(1000150010, "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR"), + std::make_pair(1000150011, "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR"), + std::make_pair(1000150012, "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR"), + std::make_pair(1000150013, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR"), + std::make_pair(1000150014, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR"), + std::make_pair(1000150017, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR"), + std::make_pair(1000150020, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR"), + std::make_pair(1000347000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR"), + std::make_pair(1000347001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR"), + std::make_pair(1000150015, "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR"), + std::make_pair(1000150016, "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR"), + std::make_pair(1000150018, "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR"), + std::make_pair(1000348013, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR"), + std::make_pair(1000152000, "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV"), + std::make_pair(1000154000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV"), + std::make_pair(1000154001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV"), + std::make_pair(1000158000, "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT"), + std::make_pair(1000158002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT"), + std::make_pair(1000158003, "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT"), + std::make_pair(1000158004, "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT"), + std::make_pair(1000158005, "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT"), + std::make_pair(1000158006, "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT"), + std::make_pair(1000160000, "VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT"), + std::make_pair(1000160001, "VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT"), + std::make_pair(1000163000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR"), + std::make_pair(1000163001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR"), + std::make_pair(1000164000, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV"), + std::make_pair(1000164001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV"), + std::make_pair(1000164002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV"), + std::make_pair(1000164005, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV"), + std::make_pair(1000165000, "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV"), + std::make_pair(1000165001, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV"), + std::make_pair(1000165003, "VK_STRUCTURE_TYPE_GEOMETRY_NV"), + std::make_pair(1000165004, "VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV"), + std::make_pair(1000165005, "VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV"), + std::make_pair(1000165006, "VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV"), + std::make_pair(1000165007, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV"), + std::make_pair(1000165008, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV"), + std::make_pair(1000165009, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV"), + std::make_pair(1000165011, "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV"), + std::make_pair(1000165012, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV"), + std::make_pair(1000166000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV"), + std::make_pair(1000166001, "VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV"), + std::make_pair(1000170000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT"), + std::make_pair(1000170001, "VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT"), + std::make_pair(1000174000, "VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT"), + std::make_pair(1000178000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT"), + std::make_pair(1000178001, "VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT"), + std::make_pair(1000178002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT"), + std::make_pair(1000181000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR"), + std::make_pair(1000183000, "VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD"), + std::make_pair(1000184000, "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT"), + std::make_pair(1000185000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD"), + std::make_pair(1000187000, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT"), + std::make_pair(1000187001, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT"), + std::make_pair(1000187002, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT"), + std::make_pair(1000187003, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT"), + std::make_pair(1000187004, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT"), + std::make_pair(1000187005, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT"), + std::make_pair(1000187006, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT"), + std::make_pair(1000189000, "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD"), + std::make_pair(1000190000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT"), + std::make_pair(1000190001, "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT"), + std::make_pair(1000190002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT"), + std::make_pair(1000191000, "VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP"), + std::make_pair(1000192000, "VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT"), + std::make_pair(1000201000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV"), + std::make_pair(1000202000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV"), + std::make_pair(1000202001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV"), + std::make_pair(1000203000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV"), + std::make_pair(1000204000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV"), + std::make_pair(1000205000, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV"), + std::make_pair(1000205002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV"), + std::make_pair(1000206000, "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV"), + std::make_pair(1000206001, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV"), + std::make_pair(1000209000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL"), + std::make_pair(1000210000, "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL"), + std::make_pair(1000210001, "VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL"), + std::make_pair(1000210002, "VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL"), + std::make_pair(1000210003, "VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL"), + std::make_pair(1000210004, "VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL"), + std::make_pair(1000210005, "VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL"), + std::make_pair(1000212000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT"), + std::make_pair(1000213000, "VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD"), + std::make_pair(1000213001, "VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD"), + std::make_pair(1000214000, "VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA"), + std::make_pair(1000215000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR"), + std::make_pair(1000217000, "VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT"), + std::make_pair(1000218000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT"), + std::make_pair(1000218001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT"), + std::make_pair(1000218002, "VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT"), + std::make_pair(1000225000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT"), + std::make_pair(1000225001, "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT"), + std::make_pair(1000225002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT"), + std::make_pair(1000226000, "VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR"), + std::make_pair(1000226001, "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR"), + std::make_pair(1000226002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR"), + std::make_pair(1000226003, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR"), + std::make_pair(1000226004, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR"), + std::make_pair(1000227000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD"), + std::make_pair(1000229000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD"), + std::make_pair(1000234000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT"), + std::make_pair(1000237000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT"), + std::make_pair(1000238000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT"), + std::make_pair(1000238001, "VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT"), + std::make_pair(1000239000, "VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR"), + std::make_pair(1000240000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV"), + std::make_pair(1000244000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT"), + std::make_pair(1000244002, "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT"), + std::make_pair(1000245000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT"), + std::make_pair(1000247000, "VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT"), + std::make_pair(1000248000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR"), + std::make_pair(1000249000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV"), + std::make_pair(1000249001, "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV"), + std::make_pair(1000249002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV"), + std::make_pair(1000250000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV"), + std::make_pair(1000250001, "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV"), + std::make_pair(1000250002, "VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV"), + std::make_pair(1000251000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT"), + std::make_pair(1000252000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT"), + std::make_pair(1000254000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT"), + std::make_pair(1000254001, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT"), + std::make_pair(1000254002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT"), + std::make_pair(1000255000, "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT"), + std::make_pair(1000255002, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT"), + std::make_pair(1000255001, "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT"), + std::make_pair(1000256000, "VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT"), + std::make_pair(1000259000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT"), + std::make_pair(1000259001, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT"), + std::make_pair(1000259002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT"), + std::make_pair(1000260000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT"), + std::make_pair(1000265000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT"), + std::make_pair(1000267000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT"), + std::make_pair(1000269000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR"), + std::make_pair(1000269001, "VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR"), + std::make_pair(1000269002, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR"), + std::make_pair(1000269003, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR"), + std::make_pair(1000269004, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR"), + std::make_pair(1000269005, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR"), + std::make_pair(1000273000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT"), + std::make_pair(1000276000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT"), + std::make_pair(1000277000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV"), + std::make_pair(1000277001, "VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV"), + std::make_pair(1000277002, "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV"), + std::make_pair(1000277003, "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV"), + std::make_pair(1000277004, "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV"), + std::make_pair(1000277005, "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV"), + std::make_pair(1000277006, "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV"), + std::make_pair(1000277007, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV"), + std::make_pair(1000278000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV"), + std::make_pair(1000278001, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV"), + std::make_pair(1000280000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR"), + std::make_pair(1000280001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR"), + std::make_pair(1000281000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT"), + std::make_pair(1000281001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT"), + std::make_pair(1000282000, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM"), + std::make_pair(1000282001, "VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM"), + std::make_pair(1000284000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT"), + std::make_pair(1000284001, "VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT"), + std::make_pair(1000284002, "VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT"), + std::make_pair(1000286000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT"), + std::make_pair(1000286001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT"), + std::make_pair(1000287000, "VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT"), + std::make_pair(1000287001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT"), + std::make_pair(1000287002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT"), + std::make_pair(1000290000, "VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR"), + std::make_pair(1000294000, "VK_STRUCTURE_TYPE_PRESENT_ID_KHR"), + std::make_pair(1000294001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR"), + std::make_pair(1000295000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT"), + std::make_pair(1000295001, "VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT"), + std::make_pair(1000295002, "VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT"), + std::make_pair(1000297000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT"), + std::make_pair(1000299000, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR"), + std::make_pair(1000299001, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR"), + std::make_pair(1000299002, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR"), + std::make_pair(1000300000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV"), + std::make_pair(1000300001, "VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV"), + std::make_pair(1000308000, "VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR"), + std::make_pair(1000309000, "VK_STRUCTURE_TYPE_RESERVED_QCOM"), + std::make_pair(1000314000, "VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR"), + std::make_pair(1000314001, "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR"), + std::make_pair(1000314002, "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR"), + std::make_pair(1000314003, "VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR"), + std::make_pair(1000314004, "VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR"), + std::make_pair(1000314005, "VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR"), + std::make_pair(1000314006, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR"), + std::make_pair(1000314007, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR"), + std::make_pair(1000314008, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV"), + std::make_pair(1000314009, "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV"), + std::make_pair(1000323000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR"), + std::make_pair(1000325000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR"), + std::make_pair(1000326000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV"), + std::make_pair(1000326001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV"), + std::make_pair(1000326002, "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV"), + std::make_pair(1000327000, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV"), + std::make_pair(1000327001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV"), + std::make_pair(1000327002, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV"), + std::make_pair(1000330000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT"), + std::make_pair(1000332000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT"), + std::make_pair(1000332001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT"), + std::make_pair(1000333000, "VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM"), + std::make_pair(1000335000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT"), + std::make_pair(1000336000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR"), + std::make_pair(1000337000, "VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR"), + std::make_pair(1000337001, "VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR"), + std::make_pair(1000337002, "VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR"), + std::make_pair(1000337003, "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR"), + std::make_pair(1000337004, "VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR"), + std::make_pair(1000337005, "VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR"), + std::make_pair(1000337006, "VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR"), + std::make_pair(1000337007, "VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR"), + std::make_pair(1000337008, "VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR"), + std::make_pair(1000337009, "VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR"), + std::make_pair(1000337010, "VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR"), + std::make_pair(1000340000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT"), + std::make_pair(1000342000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM"), + std::make_pair(1000344000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT"), + std::make_pair(1000346000, "VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT"), + std::make_pair(1000351000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE"), + std::make_pair(1000351002, "VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE"), + std::make_pair(1000352000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT"), + std::make_pair(1000352001, "VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT"), + std::make_pair(1000352002, "VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT"), + std::make_pair(1000353000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT"), + std::make_pair(1000355000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT"), + std::make_pair(1000355001, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT"), + std::make_pair(1000356000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT"), + std::make_pair(1000360000, "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR"), + std::make_pair(1000364000, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA"), + std::make_pair(1000364001, "VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA"), + std::make_pair(1000364002, "VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA"), + std::make_pair(1000365000, "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA"), + std::make_pair(1000365001, "VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA"), + std::make_pair(1000366000, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA"), + std::make_pair(1000366001, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA"), + std::make_pair(1000366002, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA"), + std::make_pair(1000366003, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA"), + std::make_pair(1000366004, "VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA"), + std::make_pair(1000366005, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA"), + std::make_pair(1000366006, "VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA"), + std::make_pair(1000366007, "VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA"), + std::make_pair(1000366008, "VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA"), + std::make_pair(1000366009, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA"), + std::make_pair(1000369000, "VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI"), + std::make_pair(1000369001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI"), + std::make_pair(1000369002, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI"), + std::make_pair(1000370000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI"), + std::make_pair(1000371000, "VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV"), + std::make_pair(1000371001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV"), + std::make_pair(1000377000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT"), + std::make_pair(1000378000, "VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX"), + std::make_pair(1000381000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT"), + std::make_pair(1000381001, "VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT"), + std::make_pair(1000388000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT"), + std::make_pair(1000388001, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT"), + std::make_pair(1000391000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT"), + std::make_pair(1000391001, "VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT"), + std::make_pair(1000392000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT"), + std::make_pair(1000392001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT"), + std::make_pair(1000411000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT"), + std::make_pair(1000411001, "VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT"), + std::make_pair(1000412000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT"), + std::make_pair(1000413000, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR"), + std::make_pair(1000413001, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR"), + std::make_pair(1000413002, "VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR"), + std::make_pair(1000413003, "VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR"), + std::make_pair(1000435000, "VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT"), +}; +static void print_VkStructureType(VkStructureType obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkStructureType_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkStructureType_map[obj] << "\"" << std::endl; +} +static void print_VkStructureType(const VkStructureType * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkStructureType_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkStructureType_map[*obj] << "\"" << std::endl; +} + +static std::map VkAccessFlagBits_map = { + std::make_pair(1ULL << 0, "VK_ACCESS_INDIRECT_COMMAND_READ_BIT"), + std::make_pair(1ULL << 1, "VK_ACCESS_INDEX_READ_BIT"), + std::make_pair(1ULL << 2, "VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT"), + std::make_pair(1ULL << 3, "VK_ACCESS_UNIFORM_READ_BIT"), + std::make_pair(1ULL << 4, "VK_ACCESS_INPUT_ATTACHMENT_READ_BIT"), + std::make_pair(1ULL << 5, "VK_ACCESS_SHADER_READ_BIT"), + std::make_pair(1ULL << 6, "VK_ACCESS_SHADER_WRITE_BIT"), + std::make_pair(1ULL << 7, "VK_ACCESS_COLOR_ATTACHMENT_READ_BIT"), + std::make_pair(1ULL << 8, "VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT"), + std::make_pair(1ULL << 9, "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT"), + std::make_pair(1ULL << 10, "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT"), + std::make_pair(1ULL << 11, "VK_ACCESS_TRANSFER_READ_BIT"), + std::make_pair(1ULL << 12, "VK_ACCESS_TRANSFER_WRITE_BIT"), + std::make_pair(1ULL << 13, "VK_ACCESS_HOST_READ_BIT"), + std::make_pair(1ULL << 14, "VK_ACCESS_HOST_WRITE_BIT"), + std::make_pair(1ULL << 15, "VK_ACCESS_MEMORY_READ_BIT"), + std::make_pair(1ULL << 16, "VK_ACCESS_MEMORY_WRITE_BIT"), + std::make_pair(1ULL << 25, "VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT"), + std::make_pair(1ULL << 26, "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT"), + std::make_pair(1ULL << 27, "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT"), + std::make_pair(1ULL << 20, "VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT"), + std::make_pair(1ULL << 19, "VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT"), + std::make_pair(1ULL << 21, "VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR"), + std::make_pair(1ULL << 22, "VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR"), + std::make_pair(1ULL << 24, "VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT"), + std::make_pair(1ULL << 23, "VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR"), + std::make_pair(1ULL << 17, "VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV"), + std::make_pair(1ULL << 18, "VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV"), + std::make_pair(0, "VK_ACCESS_NONE_KHR"), +}; +static void print_VkAccessFlagBits(VkAccessFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkAccessFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkAccessFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkAccessFlagBits(const VkAccessFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkAccessFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkAccessFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkImageLayout_map = { + std::make_pair(0, "VK_IMAGE_LAYOUT_UNDEFINED"), + std::make_pair(1, "VK_IMAGE_LAYOUT_GENERAL"), + std::make_pair(2, "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL"), + std::make_pair(3, "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + std::make_pair(4, "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + std::make_pair(5, "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL"), + std::make_pair(6, "VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL"), + std::make_pair(7, "VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL"), + std::make_pair(8, "VK_IMAGE_LAYOUT_PREINITIALIZED"), + std::make_pair(1000117000, "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL"), + std::make_pair(1000117001, "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL"), + std::make_pair(1000241000, "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL"), + std::make_pair(1000241001, "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL"), + std::make_pair(1000241002, "VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL"), + std::make_pair(1000241003, "VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL"), + std::make_pair(1000001002, "VK_IMAGE_LAYOUT_PRESENT_SRC_KHR"), + std::make_pair(1000024000, "VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR"), + std::make_pair(1000024001, "VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR"), + std::make_pair(1000024002, "VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR"), + std::make_pair(1000111000, "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR"), + std::make_pair(1000218000, "VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"), + std::make_pair(1000164003, "VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR"), + std::make_pair(1000299000, "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR"), + std::make_pair(1000299001, "VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR"), + std::make_pair(1000299002, "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR"), + std::make_pair(1000314000, "VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR"), + std::make_pair(1000314001, "VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR"), +}; +static void print_VkImageLayout(VkImageLayout obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkImageLayout_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkImageLayout_map[obj] << "\"" << std::endl; +} +static void print_VkImageLayout(const VkImageLayout * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkImageLayout_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkImageLayout_map[*obj] << "\"" << std::endl; +} + +static std::map VkImageAspectFlagBits_map = { + std::make_pair(1ULL << 0, "VK_IMAGE_ASPECT_COLOR_BIT"), + std::make_pair(1ULL << 1, "VK_IMAGE_ASPECT_DEPTH_BIT"), + std::make_pair(1ULL << 2, "VK_IMAGE_ASPECT_STENCIL_BIT"), + std::make_pair(1ULL << 3, "VK_IMAGE_ASPECT_METADATA_BIT"), + std::make_pair(1ULL << 4, "VK_IMAGE_ASPECT_PLANE_0_BIT"), + std::make_pair(1ULL << 5, "VK_IMAGE_ASPECT_PLANE_1_BIT"), + std::make_pair(1ULL << 6, "VK_IMAGE_ASPECT_PLANE_2_BIT"), + std::make_pair(1ULL << 7, "VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT"), + std::make_pair(1ULL << 8, "VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT"), + std::make_pair(1ULL << 9, "VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT"), + std::make_pair(1ULL << 10, "VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT"), + std::make_pair(0, "VK_IMAGE_ASPECT_NONE_KHR"), +}; +static void print_VkImageAspectFlagBits(VkImageAspectFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkImageAspectFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkImageAspectFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkImageAspectFlagBits(const VkImageAspectFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkImageAspectFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkImageAspectFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkObjectType_map = { + std::make_pair(0, "VK_OBJECT_TYPE_UNKNOWN"), + std::make_pair(1, "VK_OBJECT_TYPE_INSTANCE"), + std::make_pair(2, "VK_OBJECT_TYPE_PHYSICAL_DEVICE"), + std::make_pair(3, "VK_OBJECT_TYPE_DEVICE"), + std::make_pair(4, "VK_OBJECT_TYPE_QUEUE"), + std::make_pair(5, "VK_OBJECT_TYPE_SEMAPHORE"), + std::make_pair(6, "VK_OBJECT_TYPE_COMMAND_BUFFER"), + std::make_pair(7, "VK_OBJECT_TYPE_FENCE"), + std::make_pair(8, "VK_OBJECT_TYPE_DEVICE_MEMORY"), + std::make_pair(9, "VK_OBJECT_TYPE_BUFFER"), + std::make_pair(10, "VK_OBJECT_TYPE_IMAGE"), + std::make_pair(11, "VK_OBJECT_TYPE_EVENT"), + std::make_pair(12, "VK_OBJECT_TYPE_QUERY_POOL"), + std::make_pair(13, "VK_OBJECT_TYPE_BUFFER_VIEW"), + std::make_pair(14, "VK_OBJECT_TYPE_IMAGE_VIEW"), + std::make_pair(16, "VK_OBJECT_TYPE_PIPELINE_CACHE"), + std::make_pair(17, "VK_OBJECT_TYPE_PIPELINE_LAYOUT"), + std::make_pair(18, "VK_OBJECT_TYPE_RENDER_PASS"), + std::make_pair(19, "VK_OBJECT_TYPE_PIPELINE"), + std::make_pair(20, "VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT"), + std::make_pair(21, "VK_OBJECT_TYPE_SAMPLER"), + std::make_pair(22, "VK_OBJECT_TYPE_DESCRIPTOR_POOL"), + std::make_pair(23, "VK_OBJECT_TYPE_DESCRIPTOR_SET"), + std::make_pair(24, "VK_OBJECT_TYPE_FRAMEBUFFER"), + std::make_pair(25, "VK_OBJECT_TYPE_COMMAND_POOL"), + std::make_pair(1000156000, "VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION"), + std::make_pair(1000000000, "VK_OBJECT_TYPE_SURFACE_KHR"), + std::make_pair(1000001000, "VK_OBJECT_TYPE_SWAPCHAIN_KHR"), + std::make_pair(1000002000, "VK_OBJECT_TYPE_DISPLAY_KHR"), + std::make_pair(1000002001, "VK_OBJECT_TYPE_DISPLAY_MODE_KHR"), + std::make_pair(1000011000, "VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT"), + std::make_pair(1000023000, "VK_OBJECT_TYPE_VIDEO_SESSION_KHR"), + std::make_pair(1000023001, "VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR"), + std::make_pair(1000029000, "VK_OBJECT_TYPE_CU_MODULE_NVX"), + std::make_pair(1000029001, "VK_OBJECT_TYPE_CU_FUNCTION_NVX"), + std::make_pair(1000128000, "VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT"), + std::make_pair(1000150000, "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR"), + std::make_pair(1000160000, "VK_OBJECT_TYPE_VALIDATION_CACHE_EXT"), + std::make_pair(1000165000, "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV"), + std::make_pair(1000210000, "VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL"), + std::make_pair(1000268000, "VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR"), + std::make_pair(1000277000, "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV"), + std::make_pair(1000295000, "VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT"), + std::make_pair(1000366000, "VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA"), +}; +static void print_VkObjectType(VkObjectType obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkObjectType_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkObjectType_map[obj] << "\"" << std::endl; +} +static void print_VkObjectType(const VkObjectType * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkObjectType_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkObjectType_map[*obj] << "\"" << std::endl; +} + +static std::map VkPipelineCacheHeaderVersion_map = { + std::make_pair(1, "VK_PIPELINE_CACHE_HEADER_VERSION_ONE"), + std::make_pair(1000298001, "VK_PIPELINE_CACHE_HEADER_VERSION_SAFETY_CRITICAL_ONE"), +}; +static void print_VkPipelineCacheHeaderVersion(VkPipelineCacheHeaderVersion obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPipelineCacheHeaderVersion_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPipelineCacheHeaderVersion_map[obj] << "\"" << std::endl; +} +static void print_VkPipelineCacheHeaderVersion(const VkPipelineCacheHeaderVersion * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPipelineCacheHeaderVersion_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPipelineCacheHeaderVersion_map[*obj] << "\"" << std::endl; +} + +static std::map VkVendorId_map = { + std::make_pair(0x10001, "VK_VENDOR_ID_VIV"), + std::make_pair(0x10002, "VK_VENDOR_ID_VSI"), + std::make_pair(0x10003, "VK_VENDOR_ID_KAZAN"), + std::make_pair(0x10004, "VK_VENDOR_ID_CODEPLAY"), + std::make_pair(0x10005, "VK_VENDOR_ID_MESA"), + std::make_pair(0x10006, "VK_VENDOR_ID_POCL"), +}; +static void print_VkVendorId(VkVendorId obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkVendorId_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkVendorId_map[obj] << "\"" << std::endl; +} +static void print_VkVendorId(const VkVendorId * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkVendorId_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkVendorId_map[*obj] << "\"" << std::endl; +} + +static std::map VkSystemAllocationScope_map = { + std::make_pair(0, "VK_SYSTEM_ALLOCATION_SCOPE_COMMAND"), + std::make_pair(1, "VK_SYSTEM_ALLOCATION_SCOPE_OBJECT"), + std::make_pair(2, "VK_SYSTEM_ALLOCATION_SCOPE_CACHE"), + std::make_pair(3, "VK_SYSTEM_ALLOCATION_SCOPE_DEVICE"), + std::make_pair(4, "VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE"), +}; +static void print_VkSystemAllocationScope(VkSystemAllocationScope obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSystemAllocationScope_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSystemAllocationScope_map[obj] << "\"" << std::endl; +} +static void print_VkSystemAllocationScope(const VkSystemAllocationScope * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSystemAllocationScope_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSystemAllocationScope_map[*obj] << "\"" << std::endl; +} + +static std::map VkInternalAllocationType_map = { + std::make_pair(0, "VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE"), +}; +static void print_VkInternalAllocationType(VkInternalAllocationType obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkInternalAllocationType_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkInternalAllocationType_map[obj] << "\"" << std::endl; +} +static void print_VkInternalAllocationType(const VkInternalAllocationType * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkInternalAllocationType_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkInternalAllocationType_map[*obj] << "\"" << std::endl; +} + +static std::map VkFormat_map = { + std::make_pair(0, "VK_FORMAT_UNDEFINED"), + std::make_pair(1, "VK_FORMAT_R4G4_UNORM_PACK8"), + std::make_pair(2, "VK_FORMAT_R4G4B4A4_UNORM_PACK16"), + std::make_pair(3, "VK_FORMAT_B4G4R4A4_UNORM_PACK16"), + std::make_pair(4, "VK_FORMAT_R5G6B5_UNORM_PACK16"), + std::make_pair(5, "VK_FORMAT_B5G6R5_UNORM_PACK16"), + std::make_pair(6, "VK_FORMAT_R5G5B5A1_UNORM_PACK16"), + std::make_pair(7, "VK_FORMAT_B5G5R5A1_UNORM_PACK16"), + std::make_pair(8, "VK_FORMAT_A1R5G5B5_UNORM_PACK16"), + std::make_pair(9, "VK_FORMAT_R8_UNORM"), + std::make_pair(10, "VK_FORMAT_R8_SNORM"), + std::make_pair(11, "VK_FORMAT_R8_USCALED"), + std::make_pair(12, "VK_FORMAT_R8_SSCALED"), + std::make_pair(13, "VK_FORMAT_R8_UINT"), + std::make_pair(14, "VK_FORMAT_R8_SINT"), + std::make_pair(15, "VK_FORMAT_R8_SRGB"), + std::make_pair(16, "VK_FORMAT_R8G8_UNORM"), + std::make_pair(17, "VK_FORMAT_R8G8_SNORM"), + std::make_pair(18, "VK_FORMAT_R8G8_USCALED"), + std::make_pair(19, "VK_FORMAT_R8G8_SSCALED"), + std::make_pair(20, "VK_FORMAT_R8G8_UINT"), + std::make_pair(21, "VK_FORMAT_R8G8_SINT"), + std::make_pair(22, "VK_FORMAT_R8G8_SRGB"), + std::make_pair(23, "VK_FORMAT_R8G8B8_UNORM"), + std::make_pair(24, "VK_FORMAT_R8G8B8_SNORM"), + std::make_pair(25, "VK_FORMAT_R8G8B8_USCALED"), + std::make_pair(26, "VK_FORMAT_R8G8B8_SSCALED"), + std::make_pair(27, "VK_FORMAT_R8G8B8_UINT"), + std::make_pair(28, "VK_FORMAT_R8G8B8_SINT"), + std::make_pair(29, "VK_FORMAT_R8G8B8_SRGB"), + std::make_pair(30, "VK_FORMAT_B8G8R8_UNORM"), + std::make_pair(31, "VK_FORMAT_B8G8R8_SNORM"), + std::make_pair(32, "VK_FORMAT_B8G8R8_USCALED"), + std::make_pair(33, "VK_FORMAT_B8G8R8_SSCALED"), + std::make_pair(34, "VK_FORMAT_B8G8R8_UINT"), + std::make_pair(35, "VK_FORMAT_B8G8R8_SINT"), + std::make_pair(36, "VK_FORMAT_B8G8R8_SRGB"), + std::make_pair(37, "VK_FORMAT_R8G8B8A8_UNORM"), + std::make_pair(38, "VK_FORMAT_R8G8B8A8_SNORM"), + std::make_pair(39, "VK_FORMAT_R8G8B8A8_USCALED"), + std::make_pair(40, "VK_FORMAT_R8G8B8A8_SSCALED"), + std::make_pair(41, "VK_FORMAT_R8G8B8A8_UINT"), + std::make_pair(42, "VK_FORMAT_R8G8B8A8_SINT"), + std::make_pair(43, "VK_FORMAT_R8G8B8A8_SRGB"), + std::make_pair(44, "VK_FORMAT_B8G8R8A8_UNORM"), + std::make_pair(45, "VK_FORMAT_B8G8R8A8_SNORM"), + std::make_pair(46, "VK_FORMAT_B8G8R8A8_USCALED"), + std::make_pair(47, "VK_FORMAT_B8G8R8A8_SSCALED"), + std::make_pair(48, "VK_FORMAT_B8G8R8A8_UINT"), + std::make_pair(49, "VK_FORMAT_B8G8R8A8_SINT"), + std::make_pair(50, "VK_FORMAT_B8G8R8A8_SRGB"), + std::make_pair(51, "VK_FORMAT_A8B8G8R8_UNORM_PACK32"), + std::make_pair(52, "VK_FORMAT_A8B8G8R8_SNORM_PACK32"), + std::make_pair(53, "VK_FORMAT_A8B8G8R8_USCALED_PACK32"), + std::make_pair(54, "VK_FORMAT_A8B8G8R8_SSCALED_PACK32"), + std::make_pair(55, "VK_FORMAT_A8B8G8R8_UINT_PACK32"), + std::make_pair(56, "VK_FORMAT_A8B8G8R8_SINT_PACK32"), + std::make_pair(57, "VK_FORMAT_A8B8G8R8_SRGB_PACK32"), + std::make_pair(58, "VK_FORMAT_A2R10G10B10_UNORM_PACK32"), + std::make_pair(59, "VK_FORMAT_A2R10G10B10_SNORM_PACK32"), + std::make_pair(60, "VK_FORMAT_A2R10G10B10_USCALED_PACK32"), + std::make_pair(61, "VK_FORMAT_A2R10G10B10_SSCALED_PACK32"), + std::make_pair(62, "VK_FORMAT_A2R10G10B10_UINT_PACK32"), + std::make_pair(63, "VK_FORMAT_A2R10G10B10_SINT_PACK32"), + std::make_pair(64, "VK_FORMAT_A2B10G10R10_UNORM_PACK32"), + std::make_pair(65, "VK_FORMAT_A2B10G10R10_SNORM_PACK32"), + std::make_pair(66, "VK_FORMAT_A2B10G10R10_USCALED_PACK32"), + std::make_pair(67, "VK_FORMAT_A2B10G10R10_SSCALED_PACK32"), + std::make_pair(68, "VK_FORMAT_A2B10G10R10_UINT_PACK32"), + std::make_pair(69, "VK_FORMAT_A2B10G10R10_SINT_PACK32"), + std::make_pair(70, "VK_FORMAT_R16_UNORM"), + std::make_pair(71, "VK_FORMAT_R16_SNORM"), + std::make_pair(72, "VK_FORMAT_R16_USCALED"), + std::make_pair(73, "VK_FORMAT_R16_SSCALED"), + std::make_pair(74, "VK_FORMAT_R16_UINT"), + std::make_pair(75, "VK_FORMAT_R16_SINT"), + std::make_pair(76, "VK_FORMAT_R16_SFLOAT"), + std::make_pair(77, "VK_FORMAT_R16G16_UNORM"), + std::make_pair(78, "VK_FORMAT_R16G16_SNORM"), + std::make_pair(79, "VK_FORMAT_R16G16_USCALED"), + std::make_pair(80, "VK_FORMAT_R16G16_SSCALED"), + std::make_pair(81, "VK_FORMAT_R16G16_UINT"), + std::make_pair(82, "VK_FORMAT_R16G16_SINT"), + std::make_pair(83, "VK_FORMAT_R16G16_SFLOAT"), + std::make_pair(84, "VK_FORMAT_R16G16B16_UNORM"), + std::make_pair(85, "VK_FORMAT_R16G16B16_SNORM"), + std::make_pair(86, "VK_FORMAT_R16G16B16_USCALED"), + std::make_pair(87, "VK_FORMAT_R16G16B16_SSCALED"), + std::make_pair(88, "VK_FORMAT_R16G16B16_UINT"), + std::make_pair(89, "VK_FORMAT_R16G16B16_SINT"), + std::make_pair(90, "VK_FORMAT_R16G16B16_SFLOAT"), + std::make_pair(91, "VK_FORMAT_R16G16B16A16_UNORM"), + std::make_pair(92, "VK_FORMAT_R16G16B16A16_SNORM"), + std::make_pair(93, "VK_FORMAT_R16G16B16A16_USCALED"), + std::make_pair(94, "VK_FORMAT_R16G16B16A16_SSCALED"), + std::make_pair(95, "VK_FORMAT_R16G16B16A16_UINT"), + std::make_pair(96, "VK_FORMAT_R16G16B16A16_SINT"), + std::make_pair(97, "VK_FORMAT_R16G16B16A16_SFLOAT"), + std::make_pair(98, "VK_FORMAT_R32_UINT"), + std::make_pair(99, "VK_FORMAT_R32_SINT"), + std::make_pair(100, "VK_FORMAT_R32_SFLOAT"), + std::make_pair(101, "VK_FORMAT_R32G32_UINT"), + std::make_pair(102, "VK_FORMAT_R32G32_SINT"), + std::make_pair(103, "VK_FORMAT_R32G32_SFLOAT"), + std::make_pair(104, "VK_FORMAT_R32G32B32_UINT"), + std::make_pair(105, "VK_FORMAT_R32G32B32_SINT"), + std::make_pair(106, "VK_FORMAT_R32G32B32_SFLOAT"), + std::make_pair(107, "VK_FORMAT_R32G32B32A32_UINT"), + std::make_pair(108, "VK_FORMAT_R32G32B32A32_SINT"), + std::make_pair(109, "VK_FORMAT_R32G32B32A32_SFLOAT"), + std::make_pair(110, "VK_FORMAT_R64_UINT"), + std::make_pair(111, "VK_FORMAT_R64_SINT"), + std::make_pair(112, "VK_FORMAT_R64_SFLOAT"), + std::make_pair(113, "VK_FORMAT_R64G64_UINT"), + std::make_pair(114, "VK_FORMAT_R64G64_SINT"), + std::make_pair(115, "VK_FORMAT_R64G64_SFLOAT"), + std::make_pair(116, "VK_FORMAT_R64G64B64_UINT"), + std::make_pair(117, "VK_FORMAT_R64G64B64_SINT"), + std::make_pair(118, "VK_FORMAT_R64G64B64_SFLOAT"), + std::make_pair(119, "VK_FORMAT_R64G64B64A64_UINT"), + std::make_pair(120, "VK_FORMAT_R64G64B64A64_SINT"), + std::make_pair(121, "VK_FORMAT_R64G64B64A64_SFLOAT"), + std::make_pair(122, "VK_FORMAT_B10G11R11_UFLOAT_PACK32"), + std::make_pair(123, "VK_FORMAT_E5B9G9R9_UFLOAT_PACK32"), + std::make_pair(124, "VK_FORMAT_D16_UNORM"), + std::make_pair(125, "VK_FORMAT_X8_D24_UNORM_PACK32"), + std::make_pair(126, "VK_FORMAT_D32_SFLOAT"), + std::make_pair(127, "VK_FORMAT_S8_UINT"), + std::make_pair(128, "VK_FORMAT_D16_UNORM_S8_UINT"), + std::make_pair(129, "VK_FORMAT_D24_UNORM_S8_UINT"), + std::make_pair(130, "VK_FORMAT_D32_SFLOAT_S8_UINT"), + std::make_pair(131, "VK_FORMAT_BC1_RGB_UNORM_BLOCK"), + std::make_pair(132, "VK_FORMAT_BC1_RGB_SRGB_BLOCK"), + std::make_pair(133, "VK_FORMAT_BC1_RGBA_UNORM_BLOCK"), + std::make_pair(134, "VK_FORMAT_BC1_RGBA_SRGB_BLOCK"), + std::make_pair(135, "VK_FORMAT_BC2_UNORM_BLOCK"), + std::make_pair(136, "VK_FORMAT_BC2_SRGB_BLOCK"), + std::make_pair(137, "VK_FORMAT_BC3_UNORM_BLOCK"), + std::make_pair(138, "VK_FORMAT_BC3_SRGB_BLOCK"), + std::make_pair(139, "VK_FORMAT_BC4_UNORM_BLOCK"), + std::make_pair(140, "VK_FORMAT_BC4_SNORM_BLOCK"), + std::make_pair(141, "VK_FORMAT_BC5_UNORM_BLOCK"), + std::make_pair(142, "VK_FORMAT_BC5_SNORM_BLOCK"), + std::make_pair(143, "VK_FORMAT_BC6H_UFLOAT_BLOCK"), + std::make_pair(144, "VK_FORMAT_BC6H_SFLOAT_BLOCK"), + std::make_pair(145, "VK_FORMAT_BC7_UNORM_BLOCK"), + std::make_pair(146, "VK_FORMAT_BC7_SRGB_BLOCK"), + std::make_pair(147, "VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK"), + std::make_pair(148, "VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK"), + std::make_pair(149, "VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK"), + std::make_pair(150, "VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK"), + std::make_pair(151, "VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK"), + std::make_pair(152, "VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK"), + std::make_pair(153, "VK_FORMAT_EAC_R11_UNORM_BLOCK"), + std::make_pair(154, "VK_FORMAT_EAC_R11_SNORM_BLOCK"), + std::make_pair(155, "VK_FORMAT_EAC_R11G11_UNORM_BLOCK"), + std::make_pair(156, "VK_FORMAT_EAC_R11G11_SNORM_BLOCK"), + std::make_pair(157, "VK_FORMAT_ASTC_4x4_UNORM_BLOCK"), + std::make_pair(158, "VK_FORMAT_ASTC_4x4_SRGB_BLOCK"), + std::make_pair(159, "VK_FORMAT_ASTC_5x4_UNORM_BLOCK"), + std::make_pair(160, "VK_FORMAT_ASTC_5x4_SRGB_BLOCK"), + std::make_pair(161, "VK_FORMAT_ASTC_5x5_UNORM_BLOCK"), + std::make_pair(162, "VK_FORMAT_ASTC_5x5_SRGB_BLOCK"), + std::make_pair(163, "VK_FORMAT_ASTC_6x5_UNORM_BLOCK"), + std::make_pair(164, "VK_FORMAT_ASTC_6x5_SRGB_BLOCK"), + std::make_pair(165, "VK_FORMAT_ASTC_6x6_UNORM_BLOCK"), + std::make_pair(166, "VK_FORMAT_ASTC_6x6_SRGB_BLOCK"), + std::make_pair(167, "VK_FORMAT_ASTC_8x5_UNORM_BLOCK"), + std::make_pair(168, "VK_FORMAT_ASTC_8x5_SRGB_BLOCK"), + std::make_pair(169, "VK_FORMAT_ASTC_8x6_UNORM_BLOCK"), + std::make_pair(170, "VK_FORMAT_ASTC_8x6_SRGB_BLOCK"), + std::make_pair(171, "VK_FORMAT_ASTC_8x8_UNORM_BLOCK"), + std::make_pair(172, "VK_FORMAT_ASTC_8x8_SRGB_BLOCK"), + std::make_pair(173, "VK_FORMAT_ASTC_10x5_UNORM_BLOCK"), + std::make_pair(174, "VK_FORMAT_ASTC_10x5_SRGB_BLOCK"), + std::make_pair(175, "VK_FORMAT_ASTC_10x6_UNORM_BLOCK"), + std::make_pair(176, "VK_FORMAT_ASTC_10x6_SRGB_BLOCK"), + std::make_pair(177, "VK_FORMAT_ASTC_10x8_UNORM_BLOCK"), + std::make_pair(178, "VK_FORMAT_ASTC_10x8_SRGB_BLOCK"), + std::make_pair(179, "VK_FORMAT_ASTC_10x10_UNORM_BLOCK"), + std::make_pair(180, "VK_FORMAT_ASTC_10x10_SRGB_BLOCK"), + std::make_pair(181, "VK_FORMAT_ASTC_12x10_UNORM_BLOCK"), + std::make_pair(182, "VK_FORMAT_ASTC_12x10_SRGB_BLOCK"), + std::make_pair(183, "VK_FORMAT_ASTC_12x12_UNORM_BLOCK"), + std::make_pair(184, "VK_FORMAT_ASTC_12x12_SRGB_BLOCK"), + std::make_pair(1000156000, "VK_FORMAT_G8B8G8R8_422_UNORM"), + std::make_pair(1000156001, "VK_FORMAT_B8G8R8G8_422_UNORM"), + std::make_pair(1000156002, "VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM"), + std::make_pair(1000156003, "VK_FORMAT_G8_B8R8_2PLANE_420_UNORM"), + std::make_pair(1000156004, "VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM"), + std::make_pair(1000156005, "VK_FORMAT_G8_B8R8_2PLANE_422_UNORM"), + std::make_pair(1000156006, "VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM"), + std::make_pair(1000156007, "VK_FORMAT_R10X6_UNORM_PACK16"), + std::make_pair(1000156008, "VK_FORMAT_R10X6G10X6_UNORM_2PACK16"), + std::make_pair(1000156009, "VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16"), + std::make_pair(1000156010, "VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16"), + std::make_pair(1000156011, "VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16"), + std::make_pair(1000156012, "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16"), + std::make_pair(1000156013, "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16"), + std::make_pair(1000156014, "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16"), + std::make_pair(1000156015, "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16"), + std::make_pair(1000156016, "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16"), + std::make_pair(1000156017, "VK_FORMAT_R12X4_UNORM_PACK16"), + std::make_pair(1000156018, "VK_FORMAT_R12X4G12X4_UNORM_2PACK16"), + std::make_pair(1000156019, "VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16"), + std::make_pair(1000156020, "VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16"), + std::make_pair(1000156021, "VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16"), + std::make_pair(1000156022, "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16"), + std::make_pair(1000156023, "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16"), + std::make_pair(1000156024, "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16"), + std::make_pair(1000156025, "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16"), + std::make_pair(1000156026, "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16"), + std::make_pair(1000156027, "VK_FORMAT_G16B16G16R16_422_UNORM"), + std::make_pair(1000156028, "VK_FORMAT_B16G16R16G16_422_UNORM"), + std::make_pair(1000156029, "VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM"), + std::make_pair(1000156030, "VK_FORMAT_G16_B16R16_2PLANE_420_UNORM"), + std::make_pair(1000156031, "VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM"), + std::make_pair(1000156032, "VK_FORMAT_G16_B16R16_2PLANE_422_UNORM"), + std::make_pair(1000156033, "VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM"), + std::make_pair(1000054000, "VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG"), + std::make_pair(1000054001, "VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG"), + std::make_pair(1000054002, "VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG"), + std::make_pair(1000054003, "VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG"), + std::make_pair(1000054004, "VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG"), + std::make_pair(1000054005, "VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG"), + std::make_pair(1000054006, "VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG"), + std::make_pair(1000054007, "VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG"), + std::make_pair(1000066000, "VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT"), + std::make_pair(1000066001, "VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT"), + std::make_pair(1000066002, "VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT"), + std::make_pair(1000066003, "VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT"), + std::make_pair(1000066004, "VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT"), + std::make_pair(1000066005, "VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT"), + std::make_pair(1000066006, "VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT"), + std::make_pair(1000066007, "VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT"), + std::make_pair(1000066008, "VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT"), + std::make_pair(1000066009, "VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT"), + std::make_pair(1000066010, "VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT"), + std::make_pair(1000066011, "VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT"), + std::make_pair(1000066012, "VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT"), + std::make_pair(1000066013, "VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT"), + std::make_pair(1000288000, "VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT"), + std::make_pair(1000288001, "VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT"), + std::make_pair(1000288002, "VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT"), + std::make_pair(1000288003, "VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT"), + std::make_pair(1000288004, "VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT"), + std::make_pair(1000288005, "VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT"), + std::make_pair(1000288006, "VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT"), + std::make_pair(1000288007, "VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT"), + std::make_pair(1000288008, "VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT"), + std::make_pair(1000288009, "VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT"), + std::make_pair(1000288010, "VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT"), + std::make_pair(1000288011, "VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT"), + std::make_pair(1000288012, "VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT"), + std::make_pair(1000288013, "VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT"), + std::make_pair(1000288014, "VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT"), + std::make_pair(1000288015, "VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT"), + std::make_pair(1000288016, "VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT"), + std::make_pair(1000288017, "VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT"), + std::make_pair(1000288018, "VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT"), + std::make_pair(1000288019, "VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT"), + std::make_pair(1000288020, "VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT"), + std::make_pair(1000288021, "VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT"), + std::make_pair(1000288022, "VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT"), + std::make_pair(1000288023, "VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT"), + std::make_pair(1000288024, "VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT"), + std::make_pair(1000288025, "VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT"), + std::make_pair(1000288026, "VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT"), + std::make_pair(1000288027, "VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT"), + std::make_pair(1000288028, "VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT"), + std::make_pair(1000288029, "VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT"), + std::make_pair(1000330000, "VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT"), + std::make_pair(1000330001, "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT"), + std::make_pair(1000330002, "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT"), + std::make_pair(1000330003, "VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT"), + std::make_pair(1000340000, "VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT"), + std::make_pair(1000340001, "VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT"), +}; +static void print_VkFormat(VkFormat obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFormat_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFormat_map[obj] << "\"" << std::endl; +} +static void print_VkFormat(const VkFormat * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFormat_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFormat_map[*obj] << "\"" << std::endl; +} + +static std::map VkFormatFeatureFlagBits_map = { + std::make_pair(1ULL << 0, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT"), + std::make_pair(1ULL << 1, "VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT"), + std::make_pair(1ULL << 2, "VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT"), + std::make_pair(1ULL << 3, "VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT"), + std::make_pair(1ULL << 4, "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT"), + std::make_pair(1ULL << 5, "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"), + std::make_pair(1ULL << 6, "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT"), + std::make_pair(1ULL << 7, "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT"), + std::make_pair(1ULL << 8, "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT"), + std::make_pair(1ULL << 9, "VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT"), + std::make_pair(1ULL << 10, "VK_FORMAT_FEATURE_BLIT_SRC_BIT"), + std::make_pair(1ULL << 11, "VK_FORMAT_FEATURE_BLIT_DST_BIT"), + std::make_pair(1ULL << 12, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT"), + std::make_pair(1ULL << 14, "VK_FORMAT_FEATURE_TRANSFER_SRC_BIT"), + std::make_pair(1ULL << 15, "VK_FORMAT_FEATURE_TRANSFER_DST_BIT"), + std::make_pair(1ULL << 17, "VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT"), + std::make_pair(1ULL << 18, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT"), + std::make_pair(1ULL << 19, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT"), + std::make_pair(1ULL << 20, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT"), + std::make_pair(1ULL << 21, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT"), + std::make_pair(1ULL << 22, "VK_FORMAT_FEATURE_DISJOINT_BIT"), + std::make_pair(1ULL << 23, "VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT"), + std::make_pair(1ULL << 16, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT"), + std::make_pair(1ULL << 13, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG"), + std::make_pair(1ULL << 25, "VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR"), + std::make_pair(1ULL << 26, "VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR"), + std::make_pair(1ULL << 29, "VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR"), + std::make_pair(1ULL << 24, "VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT"), + std::make_pair(1ULL << 30, "VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"), + std::make_pair(1ULL << 27, "VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR"), + std::make_pair(1ULL << 28, "VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR"), +}; +static void print_VkFormatFeatureFlagBits(VkFormatFeatureFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFormatFeatureFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFormatFeatureFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkFormatFeatureFlagBits(const VkFormatFeatureFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFormatFeatureFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFormatFeatureFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkImageCreateFlagBits_map = { + std::make_pair(1ULL << 0, "VK_IMAGE_CREATE_SPARSE_BINDING_BIT"), + std::make_pair(1ULL << 1, "VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT"), + std::make_pair(1ULL << 2, "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT"), + std::make_pair(1ULL << 3, "VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT"), + std::make_pair(1ULL << 4, "VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT"), + std::make_pair(1ULL << 10, "VK_IMAGE_CREATE_ALIAS_BIT"), + std::make_pair(1ULL << 6, "VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT"), + std::make_pair(1ULL << 5, "VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT"), + std::make_pair(1ULL << 7, "VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT"), + std::make_pair(1ULL << 8, "VK_IMAGE_CREATE_EXTENDED_USAGE_BIT"), + std::make_pair(1ULL << 11, "VK_IMAGE_CREATE_PROTECTED_BIT"), + std::make_pair(1ULL << 9, "VK_IMAGE_CREATE_DISJOINT_BIT"), + std::make_pair(1ULL << 13, "VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV"), + std::make_pair(1ULL << 12, "VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT"), + std::make_pair(1ULL << 14, "VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT"), + std::make_pair(1ULL << 16, "VK_IMAGE_CREATE_RESERVED_16_BIT_AMD"), + std::make_pair(1ULL << 17, "VK_IMAGE_CREATE_RESERVED_394_BIT_EXT"), + std::make_pair(1ULL << 15, "VK_IMAGE_CREATE_RESERVED_426_BIT_QCOM"), +}; +static void print_VkImageCreateFlagBits(VkImageCreateFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkImageCreateFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkImageCreateFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkImageCreateFlagBits(const VkImageCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkImageCreateFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkImageCreateFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkSampleCountFlagBits_map = { + std::make_pair(1ULL << 0, "VK_SAMPLE_COUNT_1_BIT"), + std::make_pair(1ULL << 1, "VK_SAMPLE_COUNT_2_BIT"), + std::make_pair(1ULL << 2, "VK_SAMPLE_COUNT_4_BIT"), + std::make_pair(1ULL << 3, "VK_SAMPLE_COUNT_8_BIT"), + std::make_pair(1ULL << 4, "VK_SAMPLE_COUNT_16_BIT"), + std::make_pair(1ULL << 5, "VK_SAMPLE_COUNT_32_BIT"), + std::make_pair(1ULL << 6, "VK_SAMPLE_COUNT_64_BIT"), +}; +static void print_VkSampleCountFlagBits(VkSampleCountFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSampleCountFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSampleCountFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkSampleCountFlagBits(const VkSampleCountFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSampleCountFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSampleCountFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkImageTiling_map = { + std::make_pair(0, "VK_IMAGE_TILING_OPTIMAL"), + std::make_pair(1, "VK_IMAGE_TILING_LINEAR"), + std::make_pair(1000158000, "VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT"), +}; +static void print_VkImageTiling(VkImageTiling obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkImageTiling_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkImageTiling_map[obj] << "\"" << std::endl; +} +static void print_VkImageTiling(const VkImageTiling * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkImageTiling_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkImageTiling_map[*obj] << "\"" << std::endl; +} + +static std::map VkImageType_map = { + std::make_pair(0, "VK_IMAGE_TYPE_1D"), + std::make_pair(1, "VK_IMAGE_TYPE_2D"), + std::make_pair(2, "VK_IMAGE_TYPE_3D"), +}; +static void print_VkImageType(VkImageType obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkImageType_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkImageType_map[obj] << "\"" << std::endl; +} +static void print_VkImageType(const VkImageType * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkImageType_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkImageType_map[*obj] << "\"" << std::endl; +} + +static std::map VkImageUsageFlagBits_map = { + std::make_pair(1ULL << 0, "VK_IMAGE_USAGE_TRANSFER_SRC_BIT"), + std::make_pair(1ULL << 1, "VK_IMAGE_USAGE_TRANSFER_DST_BIT"), + std::make_pair(1ULL << 2, "VK_IMAGE_USAGE_SAMPLED_BIT"), + std::make_pair(1ULL << 3, "VK_IMAGE_USAGE_STORAGE_BIT"), + std::make_pair(1ULL << 4, "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT"), + std::make_pair(1ULL << 5, "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT"), + std::make_pair(1ULL << 6, "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT"), + std::make_pair(1ULL << 7, "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT"), + std::make_pair(1ULL << 10, "VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR"), + std::make_pair(1ULL << 11, "VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR"), + std::make_pair(1ULL << 12, "VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR"), + std::make_pair(1ULL << 16, "VK_IMAGE_USAGE_RESERVED_16_BIT_QCOM"), + std::make_pair(1ULL << 17, "VK_IMAGE_USAGE_RESERVED_17_BIT_QCOM"), + std::make_pair(1ULL << 9, "VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT"), + std::make_pair(1ULL << 8, "VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"), + std::make_pair(1ULL << 13, "VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR"), + std::make_pair(1ULL << 14, "VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR"), + std::make_pair(1ULL << 15, "VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR"), + std::make_pair(1ULL << 19, "VK_IMAGE_USAGE_RESERVED_19_BIT_EXT"), + std::make_pair(1ULL << 18, "VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI"), +}; +static void print_VkImageUsageFlagBits(VkImageUsageFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkImageUsageFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkImageUsageFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkImageUsageFlagBits(const VkImageUsageFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkImageUsageFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkImageUsageFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkMemoryHeapFlagBits_map = { + std::make_pair(1ULL << 0, "VK_MEMORY_HEAP_DEVICE_LOCAL_BIT"), + std::make_pair(1ULL << 1, "VK_MEMORY_HEAP_MULTI_INSTANCE_BIT"), + std::make_pair(1ULL << 2, "VK_MEMORY_HEAP_SEU_SAFE_BIT"), +}; +static void print_VkMemoryHeapFlagBits(VkMemoryHeapFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkMemoryHeapFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkMemoryHeapFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkMemoryHeapFlagBits(const VkMemoryHeapFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkMemoryHeapFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkMemoryHeapFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkMemoryPropertyFlagBits_map = { + std::make_pair(1ULL << 0, "VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT"), + std::make_pair(1ULL << 1, "VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT"), + std::make_pair(1ULL << 2, "VK_MEMORY_PROPERTY_HOST_COHERENT_BIT"), + std::make_pair(1ULL << 3, "VK_MEMORY_PROPERTY_HOST_CACHED_BIT"), + std::make_pair(1ULL << 4, "VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT"), + std::make_pair(1ULL << 5, "VK_MEMORY_PROPERTY_PROTECTED_BIT"), + std::make_pair(1ULL << 6, "VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD"), + std::make_pair(1ULL << 7, "VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD"), + std::make_pair(1ULL << 8, "VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV"), +}; +static void print_VkMemoryPropertyFlagBits(VkMemoryPropertyFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkMemoryPropertyFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkMemoryPropertyFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkMemoryPropertyFlagBits(const VkMemoryPropertyFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkMemoryPropertyFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkMemoryPropertyFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkPhysicalDeviceType_map = { + std::make_pair(0, "VK_PHYSICAL_DEVICE_TYPE_OTHER"), + std::make_pair(1, "VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU"), + std::make_pair(2, "VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU"), + std::make_pair(3, "VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU"), + std::make_pair(4, "VK_PHYSICAL_DEVICE_TYPE_CPU"), +}; +static void print_VkPhysicalDeviceType(VkPhysicalDeviceType obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPhysicalDeviceType_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPhysicalDeviceType_map[obj] << "\"" << std::endl; +} +static void print_VkPhysicalDeviceType(const VkPhysicalDeviceType * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPhysicalDeviceType_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPhysicalDeviceType_map[*obj] << "\"" << std::endl; +} + +static std::map VkQueueFlagBits_map = { + std::make_pair(1ULL << 0, "VK_QUEUE_GRAPHICS_BIT"), + std::make_pair(1ULL << 1, "VK_QUEUE_COMPUTE_BIT"), + std::make_pair(1ULL << 2, "VK_QUEUE_TRANSFER_BIT"), + std::make_pair(1ULL << 4, "VK_QUEUE_PROTECTED_BIT"), + std::make_pair(1ULL << 5, "VK_QUEUE_VIDEO_DECODE_BIT_KHR"), + std::make_pair(1ULL << 6, "VK_QUEUE_VIDEO_ENCODE_BIT_KHR"), +}; +static void print_VkQueueFlagBits(VkQueueFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkQueueFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkQueueFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkQueueFlagBits(const VkQueueFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkQueueFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkQueueFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkDeviceQueueCreateFlagBits_map = { + std::make_pair(1ULL << 0, "VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT"), +}; +static void print_VkDeviceQueueCreateFlagBits(VkDeviceQueueCreateFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDeviceQueueCreateFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDeviceQueueCreateFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkDeviceQueueCreateFlagBits(const VkDeviceQueueCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDeviceQueueCreateFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDeviceQueueCreateFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkPipelineStageFlagBits_map = { + std::make_pair(1ULL << 0, "VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT"), + std::make_pair(1ULL << 1, "VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT"), + std::make_pair(1ULL << 2, "VK_PIPELINE_STAGE_VERTEX_INPUT_BIT"), + std::make_pair(1ULL << 3, "VK_PIPELINE_STAGE_VERTEX_SHADER_BIT"), + std::make_pair(1ULL << 4, "VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT"), + std::make_pair(1ULL << 5, "VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT"), + std::make_pair(1ULL << 6, "VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT"), + std::make_pair(1ULL << 7, "VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT"), + std::make_pair(1ULL << 8, "VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT"), + std::make_pair(1ULL << 9, "VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT"), + std::make_pair(1ULL << 10, "VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT"), + std::make_pair(1ULL << 11, "VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT"), + std::make_pair(1ULL << 12, "VK_PIPELINE_STAGE_TRANSFER_BIT"), + std::make_pair(1ULL << 13, "VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT"), + std::make_pair(1ULL << 14, "VK_PIPELINE_STAGE_HOST_BIT"), + std::make_pair(1ULL << 15, "VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT"), + std::make_pair(1ULL << 16, "VK_PIPELINE_STAGE_ALL_COMMANDS_BIT"), + std::make_pair(1ULL << 24, "VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT"), + std::make_pair(1ULL << 18, "VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT"), + std::make_pair(1ULL << 25, "VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR"), + std::make_pair(1ULL << 21, "VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR"), + std::make_pair(1ULL << 19, "VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV"), + std::make_pair(1ULL << 20, "VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV"), + std::make_pair(1ULL << 23, "VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT"), + std::make_pair(1ULL << 22, "VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"), + std::make_pair(1ULL << 17, "VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV"), + std::make_pair(0, "VK_PIPELINE_STAGE_NONE_KHR"), +}; +static void print_VkPipelineStageFlagBits(VkPipelineStageFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPipelineStageFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPipelineStageFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkPipelineStageFlagBits(const VkPipelineStageFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPipelineStageFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPipelineStageFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkFenceCreateFlagBits_map = { + std::make_pair(1ULL << 0, "VK_FENCE_CREATE_SIGNALED_BIT"), +}; +static void print_VkFenceCreateFlagBits(VkFenceCreateFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFenceCreateFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFenceCreateFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkFenceCreateFlagBits(const VkFenceCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFenceCreateFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFenceCreateFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkEventCreateFlagBits_map = { + std::make_pair(1ULL << 0, "VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR"), +}; +static void print_VkEventCreateFlagBits(VkEventCreateFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkEventCreateFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkEventCreateFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkEventCreateFlagBits(const VkEventCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkEventCreateFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkEventCreateFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkQueryPipelineStatisticFlagBits_map = { + std::make_pair(1ULL << 0, "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT"), + std::make_pair(1ULL << 1, "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT"), + std::make_pair(1ULL << 2, "VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT"), + std::make_pair(1ULL << 3, "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT"), + std::make_pair(1ULL << 4, "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT"), + std::make_pair(1ULL << 5, "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT"), + std::make_pair(1ULL << 6, "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT"), + std::make_pair(1ULL << 7, "VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT"), + std::make_pair(1ULL << 8, "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT"), + std::make_pair(1ULL << 9, "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT"), + std::make_pair(1ULL << 10, "VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT"), +}; +static void print_VkQueryPipelineStatisticFlagBits(VkQueryPipelineStatisticFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkQueryPipelineStatisticFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkQueryPipelineStatisticFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkQueryPipelineStatisticFlagBits(const VkQueryPipelineStatisticFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkQueryPipelineStatisticFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkQueryPipelineStatisticFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkQueryType_map = { + std::make_pair(0, "VK_QUERY_TYPE_OCCLUSION"), + std::make_pair(1, "VK_QUERY_TYPE_PIPELINE_STATISTICS"), + std::make_pair(2, "VK_QUERY_TYPE_TIMESTAMP"), + std::make_pair(1000023000, "VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR"), + std::make_pair(1000028004, "VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT"), + std::make_pair(1000116000, "VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR"), + std::make_pair(1000150000, "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR"), + std::make_pair(1000150001, "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR"), + std::make_pair(1000165000, "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV"), + std::make_pair(1000210000, "VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL"), + std::make_pair(1000299000, "VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR"), +}; +static void print_VkQueryType(VkQueryType obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkQueryType_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkQueryType_map[obj] << "\"" << std::endl; +} +static void print_VkQueryType(const VkQueryType * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkQueryType_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkQueryType_map[*obj] << "\"" << std::endl; +} + +static std::map VkQueryResultFlagBits_map = { + std::make_pair(1ULL << 0, "VK_QUERY_RESULT_64_BIT"), + std::make_pair(1ULL << 1, "VK_QUERY_RESULT_WAIT_BIT"), + std::make_pair(1ULL << 2, "VK_QUERY_RESULT_WITH_AVAILABILITY_BIT"), + std::make_pair(1ULL << 3, "VK_QUERY_RESULT_PARTIAL_BIT"), + std::make_pair(1ULL << 4, "VK_QUERY_RESULT_WITH_STATUS_BIT_KHR"), +}; +static void print_VkQueryResultFlagBits(VkQueryResultFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkQueryResultFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkQueryResultFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkQueryResultFlagBits(const VkQueryResultFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkQueryResultFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkQueryResultFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkBufferCreateFlagBits_map = { + std::make_pair(1ULL << 0, "VK_BUFFER_CREATE_SPARSE_BINDING_BIT"), + std::make_pair(1ULL << 1, "VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT"), + std::make_pair(1ULL << 2, "VK_BUFFER_CREATE_SPARSE_ALIASED_BIT"), + std::make_pair(1ULL << 3, "VK_BUFFER_CREATE_PROTECTED_BIT"), + std::make_pair(1ULL << 4, "VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT"), + std::make_pair(1ULL << 5, "VK_BUFFER_CREATE_RESERVED_5_BIT_AMD"), +}; +static void print_VkBufferCreateFlagBits(VkBufferCreateFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkBufferCreateFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkBufferCreateFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkBufferCreateFlagBits(const VkBufferCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkBufferCreateFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkBufferCreateFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkBufferUsageFlagBits_map = { + std::make_pair(1ULL << 0, "VK_BUFFER_USAGE_TRANSFER_SRC_BIT"), + std::make_pair(1ULL << 1, "VK_BUFFER_USAGE_TRANSFER_DST_BIT"), + std::make_pair(1ULL << 2, "VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT"), + std::make_pair(1ULL << 3, "VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT"), + std::make_pair(1ULL << 4, "VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT"), + std::make_pair(1ULL << 5, "VK_BUFFER_USAGE_STORAGE_BUFFER_BIT"), + std::make_pair(1ULL << 6, "VK_BUFFER_USAGE_INDEX_BUFFER_BIT"), + std::make_pair(1ULL << 7, "VK_BUFFER_USAGE_VERTEX_BUFFER_BIT"), + std::make_pair(1ULL << 8, "VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT"), + std::make_pair(1ULL << 17, "VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT"), + std::make_pair(1ULL << 13, "VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR"), + std::make_pair(1ULL << 14, "VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR"), + std::make_pair(1ULL << 11, "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT"), + std::make_pair(1ULL << 12, "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT"), + std::make_pair(1ULL << 9, "VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT"), + std::make_pair(1ULL << 19, "VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR"), + std::make_pair(1ULL << 20, "VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR"), + std::make_pair(1ULL << 10, "VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR"), + std::make_pair(1ULL << 18, "VK_BUFFER_USAGE_RESERVED_18_BIT_QCOM"), + std::make_pair(1ULL << 15, "VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR"), + std::make_pair(1ULL << 16, "VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR"), + std::make_pair(1ULL << 21, "VK_BUFFER_USAGE_RESERVED_21_BIT_AMD"), + std::make_pair(1ULL << 22, "VK_BUFFER_USAGE_RESERVED_22_BIT_AMD"), +}; +static void print_VkBufferUsageFlagBits(VkBufferUsageFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkBufferUsageFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkBufferUsageFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkBufferUsageFlagBits(const VkBufferUsageFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkBufferUsageFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkBufferUsageFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkSharingMode_map = { + std::make_pair(0, "VK_SHARING_MODE_EXCLUSIVE"), + std::make_pair(1, "VK_SHARING_MODE_CONCURRENT"), +}; +static void print_VkSharingMode(VkSharingMode obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSharingMode_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSharingMode_map[obj] << "\"" << std::endl; +} +static void print_VkSharingMode(const VkSharingMode * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSharingMode_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSharingMode_map[*obj] << "\"" << std::endl; +} + +static std::map VkComponentSwizzle_map = { + std::make_pair(0, "VK_COMPONENT_SWIZZLE_IDENTITY"), + std::make_pair(1, "VK_COMPONENT_SWIZZLE_ZERO"), + std::make_pair(2, "VK_COMPONENT_SWIZZLE_ONE"), + std::make_pair(3, "VK_COMPONENT_SWIZZLE_R"), + std::make_pair(4, "VK_COMPONENT_SWIZZLE_G"), + std::make_pair(5, "VK_COMPONENT_SWIZZLE_B"), + std::make_pair(6, "VK_COMPONENT_SWIZZLE_A"), +}; +static void print_VkComponentSwizzle(VkComponentSwizzle obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkComponentSwizzle_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkComponentSwizzle_map[obj] << "\"" << std::endl; +} +static void print_VkComponentSwizzle(const VkComponentSwizzle * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkComponentSwizzle_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkComponentSwizzle_map[*obj] << "\"" << std::endl; +} + +static std::map VkImageViewCreateFlagBits_map = { + std::make_pair(1ULL << 0, "VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT"), + std::make_pair(1ULL << 1, "VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT"), +}; +static void print_VkImageViewCreateFlagBits(VkImageViewCreateFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkImageViewCreateFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkImageViewCreateFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkImageViewCreateFlagBits(const VkImageViewCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkImageViewCreateFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkImageViewCreateFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkImageViewType_map = { + std::make_pair(0, "VK_IMAGE_VIEW_TYPE_1D"), + std::make_pair(1, "VK_IMAGE_VIEW_TYPE_2D"), + std::make_pair(2, "VK_IMAGE_VIEW_TYPE_3D"), + std::make_pair(3, "VK_IMAGE_VIEW_TYPE_CUBE"), + std::make_pair(4, "VK_IMAGE_VIEW_TYPE_1D_ARRAY"), + std::make_pair(5, "VK_IMAGE_VIEW_TYPE_2D_ARRAY"), + std::make_pair(6, "VK_IMAGE_VIEW_TYPE_CUBE_ARRAY"), +}; +static void print_VkImageViewType(VkImageViewType obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkImageViewType_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkImageViewType_map[obj] << "\"" << std::endl; +} +static void print_VkImageViewType(const VkImageViewType * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkImageViewType_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkImageViewType_map[*obj] << "\"" << std::endl; +} + +static std::map VkPipelineCacheCreateFlagBits_map = { + std::make_pair(1ULL << 2, "VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT"), + std::make_pair(1ULL << 1, "VK_PIPELINE_CACHE_CREATE_RESERVED_1_BIT_EXT"), + std::make_pair(1ULL << 0, "VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT"), +}; +static void print_VkPipelineCacheCreateFlagBits(VkPipelineCacheCreateFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPipelineCacheCreateFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPipelineCacheCreateFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkPipelineCacheCreateFlagBits(const VkPipelineCacheCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPipelineCacheCreateFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPipelineCacheCreateFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkBlendFactor_map = { + std::make_pair(0, "VK_BLEND_FACTOR_ZERO"), + std::make_pair(1, "VK_BLEND_FACTOR_ONE"), + std::make_pair(2, "VK_BLEND_FACTOR_SRC_COLOR"), + std::make_pair(3, "VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR"), + std::make_pair(4, "VK_BLEND_FACTOR_DST_COLOR"), + std::make_pair(5, "VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR"), + std::make_pair(6, "VK_BLEND_FACTOR_SRC_ALPHA"), + std::make_pair(7, "VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA"), + std::make_pair(8, "VK_BLEND_FACTOR_DST_ALPHA"), + std::make_pair(9, "VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA"), + std::make_pair(10, "VK_BLEND_FACTOR_CONSTANT_COLOR"), + std::make_pair(11, "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR"), + std::make_pair(12, "VK_BLEND_FACTOR_CONSTANT_ALPHA"), + std::make_pair(13, "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA"), + std::make_pair(14, "VK_BLEND_FACTOR_SRC_ALPHA_SATURATE"), + std::make_pair(15, "VK_BLEND_FACTOR_SRC1_COLOR"), + std::make_pair(16, "VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR"), + std::make_pair(17, "VK_BLEND_FACTOR_SRC1_ALPHA"), + std::make_pair(18, "VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA"), +}; +static void print_VkBlendFactor(VkBlendFactor obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkBlendFactor_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkBlendFactor_map[obj] << "\"" << std::endl; +} +static void print_VkBlendFactor(const VkBlendFactor * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkBlendFactor_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkBlendFactor_map[*obj] << "\"" << std::endl; +} + +static std::map VkBlendOp_map = { + std::make_pair(0, "VK_BLEND_OP_ADD"), + std::make_pair(1, "VK_BLEND_OP_SUBTRACT"), + std::make_pair(2, "VK_BLEND_OP_REVERSE_SUBTRACT"), + std::make_pair(3, "VK_BLEND_OP_MIN"), + std::make_pair(4, "VK_BLEND_OP_MAX"), + std::make_pair(1000148000, "VK_BLEND_OP_ZERO_EXT"), + std::make_pair(1000148001, "VK_BLEND_OP_SRC_EXT"), + std::make_pair(1000148002, "VK_BLEND_OP_DST_EXT"), + std::make_pair(1000148003, "VK_BLEND_OP_SRC_OVER_EXT"), + std::make_pair(1000148004, "VK_BLEND_OP_DST_OVER_EXT"), + std::make_pair(1000148005, "VK_BLEND_OP_SRC_IN_EXT"), + std::make_pair(1000148006, "VK_BLEND_OP_DST_IN_EXT"), + std::make_pair(1000148007, "VK_BLEND_OP_SRC_OUT_EXT"), + std::make_pair(1000148008, "VK_BLEND_OP_DST_OUT_EXT"), + std::make_pair(1000148009, "VK_BLEND_OP_SRC_ATOP_EXT"), + std::make_pair(1000148010, "VK_BLEND_OP_DST_ATOP_EXT"), + std::make_pair(1000148011, "VK_BLEND_OP_XOR_EXT"), + std::make_pair(1000148012, "VK_BLEND_OP_MULTIPLY_EXT"), + std::make_pair(1000148013, "VK_BLEND_OP_SCREEN_EXT"), + std::make_pair(1000148014, "VK_BLEND_OP_OVERLAY_EXT"), + std::make_pair(1000148015, "VK_BLEND_OP_DARKEN_EXT"), + std::make_pair(1000148016, "VK_BLEND_OP_LIGHTEN_EXT"), + std::make_pair(1000148017, "VK_BLEND_OP_COLORDODGE_EXT"), + std::make_pair(1000148018, "VK_BLEND_OP_COLORBURN_EXT"), + std::make_pair(1000148019, "VK_BLEND_OP_HARDLIGHT_EXT"), + std::make_pair(1000148020, "VK_BLEND_OP_SOFTLIGHT_EXT"), + std::make_pair(1000148021, "VK_BLEND_OP_DIFFERENCE_EXT"), + std::make_pair(1000148022, "VK_BLEND_OP_EXCLUSION_EXT"), + std::make_pair(1000148023, "VK_BLEND_OP_INVERT_EXT"), + std::make_pair(1000148024, "VK_BLEND_OP_INVERT_RGB_EXT"), + std::make_pair(1000148025, "VK_BLEND_OP_LINEARDODGE_EXT"), + std::make_pair(1000148026, "VK_BLEND_OP_LINEARBURN_EXT"), + std::make_pair(1000148027, "VK_BLEND_OP_VIVIDLIGHT_EXT"), + std::make_pair(1000148028, "VK_BLEND_OP_LINEARLIGHT_EXT"), + std::make_pair(1000148029, "VK_BLEND_OP_PINLIGHT_EXT"), + std::make_pair(1000148030, "VK_BLEND_OP_HARDMIX_EXT"), + std::make_pair(1000148031, "VK_BLEND_OP_HSL_HUE_EXT"), + std::make_pair(1000148032, "VK_BLEND_OP_HSL_SATURATION_EXT"), + std::make_pair(1000148033, "VK_BLEND_OP_HSL_COLOR_EXT"), + std::make_pair(1000148034, "VK_BLEND_OP_HSL_LUMINOSITY_EXT"), + std::make_pair(1000148035, "VK_BLEND_OP_PLUS_EXT"), + std::make_pair(1000148036, "VK_BLEND_OP_PLUS_CLAMPED_EXT"), + std::make_pair(1000148037, "VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT"), + std::make_pair(1000148038, "VK_BLEND_OP_PLUS_DARKER_EXT"), + std::make_pair(1000148039, "VK_BLEND_OP_MINUS_EXT"), + std::make_pair(1000148040, "VK_BLEND_OP_MINUS_CLAMPED_EXT"), + std::make_pair(1000148041, "VK_BLEND_OP_CONTRAST_EXT"), + std::make_pair(1000148042, "VK_BLEND_OP_INVERT_OVG_EXT"), + std::make_pair(1000148043, "VK_BLEND_OP_RED_EXT"), + std::make_pair(1000148044, "VK_BLEND_OP_GREEN_EXT"), + std::make_pair(1000148045, "VK_BLEND_OP_BLUE_EXT"), +}; +static void print_VkBlendOp(VkBlendOp obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkBlendOp_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkBlendOp_map[obj] << "\"" << std::endl; +} +static void print_VkBlendOp(const VkBlendOp * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkBlendOp_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkBlendOp_map[*obj] << "\"" << std::endl; +} + +static std::map VkColorComponentFlagBits_map = { + std::make_pair(1ULL << 0, "VK_COLOR_COMPONENT_R_BIT"), + std::make_pair(1ULL << 1, "VK_COLOR_COMPONENT_G_BIT"), + std::make_pair(1ULL << 2, "VK_COLOR_COMPONENT_B_BIT"), + std::make_pair(1ULL << 3, "VK_COLOR_COMPONENT_A_BIT"), +}; +static void print_VkColorComponentFlagBits(VkColorComponentFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkColorComponentFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkColorComponentFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkColorComponentFlagBits(const VkColorComponentFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkColorComponentFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkColorComponentFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkCompareOp_map = { + std::make_pair(0, "VK_COMPARE_OP_NEVER"), + std::make_pair(1, "VK_COMPARE_OP_LESS"), + std::make_pair(2, "VK_COMPARE_OP_EQUAL"), + std::make_pair(3, "VK_COMPARE_OP_LESS_OR_EQUAL"), + std::make_pair(4, "VK_COMPARE_OP_GREATER"), + std::make_pair(5, "VK_COMPARE_OP_NOT_EQUAL"), + std::make_pair(6, "VK_COMPARE_OP_GREATER_OR_EQUAL"), + std::make_pair(7, "VK_COMPARE_OP_ALWAYS"), +}; +static void print_VkCompareOp(VkCompareOp obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkCompareOp_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkCompareOp_map[obj] << "\"" << std::endl; +} +static void print_VkCompareOp(const VkCompareOp * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkCompareOp_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkCompareOp_map[*obj] << "\"" << std::endl; +} + +static std::map VkPipelineCreateFlagBits_map = { + std::make_pair(1ULL << 0, "VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT"), + std::make_pair(1ULL << 3, "VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT"), + std::make_pair(1ULL << 4, "VK_PIPELINE_CREATE_DISPATCH_BASE_BIT"), + std::make_pair(1ULL << 21, "VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"), + std::make_pair(1ULL << 22, "VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"), + std::make_pair(1ULL << 14, "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR"), + std::make_pair(1ULL << 15, "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR"), + std::make_pair(1ULL << 16, "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR"), + std::make_pair(1ULL << 17, "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR"), + std::make_pair(1ULL << 12, "VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR"), + std::make_pair(1ULL << 13, "VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR"), + std::make_pair(1ULL << 19, "VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR"), + std::make_pair(1ULL << 5, "VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV"), + std::make_pair(1ULL << 6, "VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR"), + std::make_pair(1ULL << 7, "VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR"), + std::make_pair(1ULL << 18, "VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV"), + std::make_pair(1ULL << 11, "VK_PIPELINE_CREATE_LIBRARY_BIT_KHR"), + std::make_pair(1ULL << 8, "VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT"), + std::make_pair(1ULL << 9, "VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT"), + std::make_pair(1ULL << 23, "VK_PIPELINE_CREATE_RESERVED_23_BIT_AMD"), + std::make_pair(1ULL << 10, "VK_PIPELINE_CREATE_RESERVED_10_BIT_AMD"), + std::make_pair(1ULL << 20, "VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV"), +}; +static void print_VkPipelineCreateFlagBits(VkPipelineCreateFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPipelineCreateFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPipelineCreateFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkPipelineCreateFlagBits(const VkPipelineCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPipelineCreateFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPipelineCreateFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkPipelineShaderStageCreateFlagBits_map = { + std::make_pair(1ULL << 2, "VK_PIPELINE_SHADER_STAGE_CREATE_RESERVED_2_BIT_NV"), + std::make_pair(1ULL << 0, "VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT"), + std::make_pair(1ULL << 1, "VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT"), + std::make_pair(1ULL << 3, "VK_PIPELINE_SHADER_STAGE_CREATE_RESERVED_3_BIT_KHR"), +}; +static void print_VkPipelineShaderStageCreateFlagBits(VkPipelineShaderStageCreateFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPipelineShaderStageCreateFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPipelineShaderStageCreateFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkPipelineShaderStageCreateFlagBits(const VkPipelineShaderStageCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPipelineShaderStageCreateFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPipelineShaderStageCreateFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkShaderStageFlagBits_map = { + std::make_pair(1ULL << 0, "VK_SHADER_STAGE_VERTEX_BIT"), + std::make_pair(1ULL << 1, "VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT"), + std::make_pair(1ULL << 2, "VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT"), + std::make_pair(1ULL << 3, "VK_SHADER_STAGE_GEOMETRY_BIT"), + std::make_pair(1ULL << 4, "VK_SHADER_STAGE_FRAGMENT_BIT"), + std::make_pair(1ULL << 5, "VK_SHADER_STAGE_COMPUTE_BIT"), + std::make_pair(0x0000001F, "VK_SHADER_STAGE_ALL_GRAPHICS"), + std::make_pair(0x7FFFFFFF, "VK_SHADER_STAGE_ALL"), + std::make_pair(1ULL << 8, "VK_SHADER_STAGE_RAYGEN_BIT_KHR"), + std::make_pair(1ULL << 9, "VK_SHADER_STAGE_ANY_HIT_BIT_KHR"), + std::make_pair(1ULL << 10, "VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR"), + std::make_pair(1ULL << 11, "VK_SHADER_STAGE_MISS_BIT_KHR"), + std::make_pair(1ULL << 12, "VK_SHADER_STAGE_INTERSECTION_BIT_KHR"), + std::make_pair(1ULL << 13, "VK_SHADER_STAGE_CALLABLE_BIT_KHR"), + std::make_pair(1ULL << 6, "VK_SHADER_STAGE_TASK_BIT_NV"), + std::make_pair(1ULL << 7, "VK_SHADER_STAGE_MESH_BIT_NV"), + std::make_pair(1ULL << 14, "VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI"), +}; +static void print_VkShaderStageFlagBits(VkShaderStageFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkShaderStageFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkShaderStageFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkShaderStageFlagBits(const VkShaderStageFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkShaderStageFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkShaderStageFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkCullModeFlagBits_map = { + std::make_pair(0, "VK_CULL_MODE_NONE"), + std::make_pair(1ULL << 0, "VK_CULL_MODE_FRONT_BIT"), + std::make_pair(1ULL << 1, "VK_CULL_MODE_BACK_BIT"), + std::make_pair(0x00000003, "VK_CULL_MODE_FRONT_AND_BACK"), +}; +static void print_VkCullModeFlagBits(VkCullModeFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkCullModeFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkCullModeFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkCullModeFlagBits(const VkCullModeFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkCullModeFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkCullModeFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkDynamicState_map = { + std::make_pair(0, "VK_DYNAMIC_STATE_VIEWPORT"), + std::make_pair(1, "VK_DYNAMIC_STATE_SCISSOR"), + std::make_pair(2, "VK_DYNAMIC_STATE_LINE_WIDTH"), + std::make_pair(3, "VK_DYNAMIC_STATE_DEPTH_BIAS"), + std::make_pair(4, "VK_DYNAMIC_STATE_BLEND_CONSTANTS"), + std::make_pair(5, "VK_DYNAMIC_STATE_DEPTH_BOUNDS"), + std::make_pair(6, "VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK"), + std::make_pair(7, "VK_DYNAMIC_STATE_STENCIL_WRITE_MASK"), + std::make_pair(8, "VK_DYNAMIC_STATE_STENCIL_REFERENCE"), + std::make_pair(1000087000, "VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV"), + std::make_pair(1000099000, "VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT"), + std::make_pair(1000143000, "VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT"), + std::make_pair(1000347000, "VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR"), + std::make_pair(1000164004, "VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV"), + std::make_pair(1000164006, "VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV"), + std::make_pair(1000205001, "VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV"), + std::make_pair(1000226000, "VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR"), + std::make_pair(1000259000, "VK_DYNAMIC_STATE_LINE_STIPPLE_EXT"), + std::make_pair(1000267000, "VK_DYNAMIC_STATE_CULL_MODE_EXT"), + std::make_pair(1000267001, "VK_DYNAMIC_STATE_FRONT_FACE_EXT"), + std::make_pair(1000267002, "VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT"), + std::make_pair(1000267003, "VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT"), + std::make_pair(1000267004, "VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT"), + std::make_pair(1000267005, "VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT"), + std::make_pair(1000267006, "VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT"), + std::make_pair(1000267007, "VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT"), + std::make_pair(1000267008, "VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT"), + std::make_pair(1000267009, "VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT"), + std::make_pair(1000267010, "VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT"), + std::make_pair(1000267011, "VK_DYNAMIC_STATE_STENCIL_OP_EXT"), + std::make_pair(1000352000, "VK_DYNAMIC_STATE_VERTEX_INPUT_EXT"), + std::make_pair(1000377000, "VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT"), + std::make_pair(1000377001, "VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT"), + std::make_pair(1000377002, "VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT"), + std::make_pair(1000377003, "VK_DYNAMIC_STATE_LOGIC_OP_EXT"), + std::make_pair(1000377004, "VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT"), + std::make_pair(1000381000, "VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT"), +}; +static void print_VkDynamicState(VkDynamicState obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDynamicState_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDynamicState_map[obj] << "\"" << std::endl; +} +static void print_VkDynamicState(const VkDynamicState * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDynamicState_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDynamicState_map[*obj] << "\"" << std::endl; +} + +static std::map VkFrontFace_map = { + std::make_pair(0, "VK_FRONT_FACE_COUNTER_CLOCKWISE"), + std::make_pair(1, "VK_FRONT_FACE_CLOCKWISE"), +}; +static void print_VkFrontFace(VkFrontFace obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFrontFace_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFrontFace_map[obj] << "\"" << std::endl; +} +static void print_VkFrontFace(const VkFrontFace * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFrontFace_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFrontFace_map[*obj] << "\"" << std::endl; +} + +static std::map VkVertexInputRate_map = { + std::make_pair(0, "VK_VERTEX_INPUT_RATE_VERTEX"), + std::make_pair(1, "VK_VERTEX_INPUT_RATE_INSTANCE"), +}; +static void print_VkVertexInputRate(VkVertexInputRate obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkVertexInputRate_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkVertexInputRate_map[obj] << "\"" << std::endl; +} +static void print_VkVertexInputRate(const VkVertexInputRate * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkVertexInputRate_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkVertexInputRate_map[*obj] << "\"" << std::endl; +} + +static std::map VkPrimitiveTopology_map = { + std::make_pair(0, "VK_PRIMITIVE_TOPOLOGY_POINT_LIST"), + std::make_pair(1, "VK_PRIMITIVE_TOPOLOGY_LINE_LIST"), + std::make_pair(2, "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP"), + std::make_pair(3, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST"), + std::make_pair(4, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP"), + std::make_pair(5, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN"), + std::make_pair(6, "VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY"), + std::make_pair(7, "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY"), + std::make_pair(8, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY"), + std::make_pair(9, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY"), + std::make_pair(10, "VK_PRIMITIVE_TOPOLOGY_PATCH_LIST"), +}; +static void print_VkPrimitiveTopology(VkPrimitiveTopology obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPrimitiveTopology_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPrimitiveTopology_map[obj] << "\"" << std::endl; +} +static void print_VkPrimitiveTopology(const VkPrimitiveTopology * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPrimitiveTopology_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPrimitiveTopology_map[*obj] << "\"" << std::endl; +} + +static std::map VkPolygonMode_map = { + std::make_pair(0, "VK_POLYGON_MODE_FILL"), + std::make_pair(1, "VK_POLYGON_MODE_LINE"), + std::make_pair(2, "VK_POLYGON_MODE_POINT"), + std::make_pair(1000153000, "VK_POLYGON_MODE_FILL_RECTANGLE_NV"), +}; +static void print_VkPolygonMode(VkPolygonMode obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPolygonMode_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPolygonMode_map[obj] << "\"" << std::endl; +} +static void print_VkPolygonMode(const VkPolygonMode * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPolygonMode_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPolygonMode_map[*obj] << "\"" << std::endl; +} + +static std::map VkStencilOp_map = { + std::make_pair(0, "VK_STENCIL_OP_KEEP"), + std::make_pair(1, "VK_STENCIL_OP_ZERO"), + std::make_pair(2, "VK_STENCIL_OP_REPLACE"), + std::make_pair(3, "VK_STENCIL_OP_INCREMENT_AND_CLAMP"), + std::make_pair(4, "VK_STENCIL_OP_DECREMENT_AND_CLAMP"), + std::make_pair(5, "VK_STENCIL_OP_INVERT"), + std::make_pair(6, "VK_STENCIL_OP_INCREMENT_AND_WRAP"), + std::make_pair(7, "VK_STENCIL_OP_DECREMENT_AND_WRAP"), +}; +static void print_VkStencilOp(VkStencilOp obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkStencilOp_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkStencilOp_map[obj] << "\"" << std::endl; +} +static void print_VkStencilOp(const VkStencilOp * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkStencilOp_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkStencilOp_map[*obj] << "\"" << std::endl; +} + +static std::map VkLogicOp_map = { + std::make_pair(0, "VK_LOGIC_OP_CLEAR"), + std::make_pair(1, "VK_LOGIC_OP_AND"), + std::make_pair(2, "VK_LOGIC_OP_AND_REVERSE"), + std::make_pair(3, "VK_LOGIC_OP_COPY"), + std::make_pair(4, "VK_LOGIC_OP_AND_INVERTED"), + std::make_pair(5, "VK_LOGIC_OP_NO_OP"), + std::make_pair(6, "VK_LOGIC_OP_XOR"), + std::make_pair(7, "VK_LOGIC_OP_OR"), + std::make_pair(8, "VK_LOGIC_OP_NOR"), + std::make_pair(9, "VK_LOGIC_OP_EQUIVALENT"), + std::make_pair(10, "VK_LOGIC_OP_INVERT"), + std::make_pair(11, "VK_LOGIC_OP_OR_REVERSE"), + std::make_pair(12, "VK_LOGIC_OP_COPY_INVERTED"), + std::make_pair(13, "VK_LOGIC_OP_OR_INVERTED"), + std::make_pair(14, "VK_LOGIC_OP_NAND"), + std::make_pair(15, "VK_LOGIC_OP_SET"), +}; +static void print_VkLogicOp(VkLogicOp obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkLogicOp_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkLogicOp_map[obj] << "\"" << std::endl; +} +static void print_VkLogicOp(const VkLogicOp * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkLogicOp_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkLogicOp_map[*obj] << "\"" << std::endl; +} + +static std::map VkBorderColor_map = { + std::make_pair(0, "VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK"), + std::make_pair(1, "VK_BORDER_COLOR_INT_TRANSPARENT_BLACK"), + std::make_pair(2, "VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK"), + std::make_pair(3, "VK_BORDER_COLOR_INT_OPAQUE_BLACK"), + std::make_pair(4, "VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE"), + std::make_pair(5, "VK_BORDER_COLOR_INT_OPAQUE_WHITE"), + std::make_pair(1000287003, "VK_BORDER_COLOR_FLOAT_CUSTOM_EXT"), + std::make_pair(1000287004, "VK_BORDER_COLOR_INT_CUSTOM_EXT"), +}; +static void print_VkBorderColor(VkBorderColor obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkBorderColor_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkBorderColor_map[obj] << "\"" << std::endl; +} +static void print_VkBorderColor(const VkBorderColor * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkBorderColor_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkBorderColor_map[*obj] << "\"" << std::endl; +} + +static std::map VkFilter_map = { + std::make_pair(0, "VK_FILTER_NEAREST"), + std::make_pair(1, "VK_FILTER_LINEAR"), + std::make_pair(1000015000, "VK_FILTER_CUBIC_IMG"), +}; +static void print_VkFilter(VkFilter obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFilter_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFilter_map[obj] << "\"" << std::endl; +} +static void print_VkFilter(const VkFilter * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFilter_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFilter_map[*obj] << "\"" << std::endl; +} + +static std::map VkSamplerAddressMode_map = { + std::make_pair(0, "VK_SAMPLER_ADDRESS_MODE_REPEAT"), + std::make_pair(1, "VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT"), + std::make_pair(2, "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE"), + std::make_pair(3, "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER"), + std::make_pair(4, "VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE"), + std::make_pair(4, "VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE"), +}; +static void print_VkSamplerAddressMode(VkSamplerAddressMode obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSamplerAddressMode_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSamplerAddressMode_map[obj] << "\"" << std::endl; +} +static void print_VkSamplerAddressMode(const VkSamplerAddressMode * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSamplerAddressMode_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSamplerAddressMode_map[*obj] << "\"" << std::endl; +} + +static std::map VkSamplerCreateFlagBits_map = { + std::make_pair(1ULL << 0, "VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT"), + std::make_pair(1ULL << 1, "VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT"), + std::make_pair(1ULL << 3, "VK_SAMPLER_CREATE_RESERVED_3_BIT_AMD"), + std::make_pair(1ULL << 2, "VK_SAMPLER_CREATE_RESERVED_2_BIT_EXT"), +}; +static void print_VkSamplerCreateFlagBits(VkSamplerCreateFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSamplerCreateFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSamplerCreateFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkSamplerCreateFlagBits(const VkSamplerCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSamplerCreateFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSamplerCreateFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkSamplerMipmapMode_map = { + std::make_pair(0, "VK_SAMPLER_MIPMAP_MODE_NEAREST"), + std::make_pair(1, "VK_SAMPLER_MIPMAP_MODE_LINEAR"), +}; +static void print_VkSamplerMipmapMode(VkSamplerMipmapMode obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSamplerMipmapMode_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSamplerMipmapMode_map[obj] << "\"" << std::endl; +} +static void print_VkSamplerMipmapMode(const VkSamplerMipmapMode * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSamplerMipmapMode_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSamplerMipmapMode_map[*obj] << "\"" << std::endl; +} + +static std::map VkDescriptorPoolCreateFlagBits_map = { + std::make_pair(1ULL << 0, "VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT"), + std::make_pair(1ULL << 1, "VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT"), + std::make_pair(1ULL << 2, "VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE"), +}; +static void print_VkDescriptorPoolCreateFlagBits(VkDescriptorPoolCreateFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDescriptorPoolCreateFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDescriptorPoolCreateFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkDescriptorPoolCreateFlagBits(const VkDescriptorPoolCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDescriptorPoolCreateFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDescriptorPoolCreateFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkDescriptorType_map = { + std::make_pair(0, "VK_DESCRIPTOR_TYPE_SAMPLER"), + std::make_pair(1, "VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER"), + std::make_pair(2, "VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE"), + std::make_pair(3, "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE"), + std::make_pair(4, "VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER"), + std::make_pair(5, "VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER"), + std::make_pair(6, "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER"), + std::make_pair(7, "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER"), + std::make_pair(8, "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC"), + std::make_pair(9, "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC"), + std::make_pair(10, "VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT"), + std::make_pair(1000138000, "VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT"), + std::make_pair(1000150000, "VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR"), + std::make_pair(1000165000, "VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV"), + std::make_pair(1000351000, "VK_DESCRIPTOR_TYPE_MUTABLE_VALVE"), +}; +static void print_VkDescriptorType(VkDescriptorType obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDescriptorType_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDescriptorType_map[obj] << "\"" << std::endl; +} +static void print_VkDescriptorType(const VkDescriptorType * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDescriptorType_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDescriptorType_map[*obj] << "\"" << std::endl; +} + +static std::map VkDescriptorSetLayoutCreateFlagBits_map = { + std::make_pair(1ULL << 1, "VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT"), + std::make_pair(1ULL << 0, "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR"), + std::make_pair(1ULL << 4, "VK_DESCRIPTOR_SET_LAYOUT_CREATE_RESERVED_4_BIT_AMD"), + std::make_pair(1ULL << 3, "VK_DESCRIPTOR_SET_LAYOUT_CREATE_RESERVED_3_BIT_AMD"), + std::make_pair(1ULL << 2, "VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE"), +}; +static void print_VkDescriptorSetLayoutCreateFlagBits(VkDescriptorSetLayoutCreateFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDescriptorSetLayoutCreateFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDescriptorSetLayoutCreateFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkDescriptorSetLayoutCreateFlagBits(const VkDescriptorSetLayoutCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDescriptorSetLayoutCreateFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDescriptorSetLayoutCreateFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkAttachmentDescriptionFlagBits_map = { + std::make_pair(1ULL << 0, "VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT"), +}; +static void print_VkAttachmentDescriptionFlagBits(VkAttachmentDescriptionFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkAttachmentDescriptionFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkAttachmentDescriptionFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkAttachmentDescriptionFlagBits(const VkAttachmentDescriptionFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkAttachmentDescriptionFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkAttachmentDescriptionFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkAttachmentLoadOp_map = { + std::make_pair(0, "VK_ATTACHMENT_LOAD_OP_LOAD"), + std::make_pair(1, "VK_ATTACHMENT_LOAD_OP_CLEAR"), + std::make_pair(2, "VK_ATTACHMENT_LOAD_OP_DONT_CARE"), + std::make_pair(1000400000, "VK_ATTACHMENT_LOAD_OP_NONE_EXT"), +}; +static void print_VkAttachmentLoadOp(VkAttachmentLoadOp obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkAttachmentLoadOp_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkAttachmentLoadOp_map[obj] << "\"" << std::endl; +} +static void print_VkAttachmentLoadOp(const VkAttachmentLoadOp * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkAttachmentLoadOp_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkAttachmentLoadOp_map[*obj] << "\"" << std::endl; +} + +static std::map VkAttachmentStoreOp_map = { + std::make_pair(0, "VK_ATTACHMENT_STORE_OP_STORE"), + std::make_pair(1, "VK_ATTACHMENT_STORE_OP_DONT_CARE"), + std::make_pair(1000301000, "VK_ATTACHMENT_STORE_OP_NONE_KHR"), +}; +static void print_VkAttachmentStoreOp(VkAttachmentStoreOp obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkAttachmentStoreOp_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkAttachmentStoreOp_map[obj] << "\"" << std::endl; +} +static void print_VkAttachmentStoreOp(const VkAttachmentStoreOp * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkAttachmentStoreOp_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkAttachmentStoreOp_map[*obj] << "\"" << std::endl; +} + +static std::map VkDependencyFlagBits_map = { + std::make_pair(1ULL << 0, "VK_DEPENDENCY_BY_REGION_BIT"), + std::make_pair(1ULL << 2, "VK_DEPENDENCY_DEVICE_GROUP_BIT"), + std::make_pair(1ULL << 1, "VK_DEPENDENCY_VIEW_LOCAL_BIT"), +}; +static void print_VkDependencyFlagBits(VkDependencyFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDependencyFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDependencyFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkDependencyFlagBits(const VkDependencyFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDependencyFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDependencyFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkFramebufferCreateFlagBits_map = { + std::make_pair(1ULL << 0, "VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT"), +}; +static void print_VkFramebufferCreateFlagBits(VkFramebufferCreateFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFramebufferCreateFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFramebufferCreateFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkFramebufferCreateFlagBits(const VkFramebufferCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFramebufferCreateFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFramebufferCreateFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkPipelineBindPoint_map = { + std::make_pair(0, "VK_PIPELINE_BIND_POINT_GRAPHICS"), + std::make_pair(1, "VK_PIPELINE_BIND_POINT_COMPUTE"), + std::make_pair(1000165000, "VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR"), + std::make_pair(1000369003, "VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI"), +}; +static void print_VkPipelineBindPoint(VkPipelineBindPoint obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPipelineBindPoint_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPipelineBindPoint_map[obj] << "\"" << std::endl; +} +static void print_VkPipelineBindPoint(const VkPipelineBindPoint * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPipelineBindPoint_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPipelineBindPoint_map[*obj] << "\"" << std::endl; +} + +static std::map VkRenderPassCreateFlagBits_map = { + std::make_pair(1ULL << 0, "VK_RENDER_PASS_CREATE_RESERVED_0_BIT_KHR"), + std::make_pair(1ULL << 1, "VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM"), +}; +static void print_VkRenderPassCreateFlagBits(VkRenderPassCreateFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkRenderPassCreateFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkRenderPassCreateFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkRenderPassCreateFlagBits(const VkRenderPassCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkRenderPassCreateFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkRenderPassCreateFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkSubpassDescriptionFlagBits_map = { + std::make_pair(1ULL << 0, "VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX"), + std::make_pair(1ULL << 1, "VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX"), + std::make_pair(1ULL << 2, "VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM"), + std::make_pair(1ULL << 3, "VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM"), + std::make_pair(1ULL << 4, "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM"), + std::make_pair(1ULL << 5, "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM"), + std::make_pair(1ULL << 6, "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM"), +}; +static void print_VkSubpassDescriptionFlagBits(VkSubpassDescriptionFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSubpassDescriptionFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSubpassDescriptionFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkSubpassDescriptionFlagBits(const VkSubpassDescriptionFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSubpassDescriptionFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSubpassDescriptionFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkCommandPoolCreateFlagBits_map = { + std::make_pair(1ULL << 0, "VK_COMMAND_POOL_CREATE_TRANSIENT_BIT"), + std::make_pair(1ULL << 1, "VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT"), + std::make_pair(1ULL << 2, "VK_COMMAND_POOL_CREATE_PROTECTED_BIT"), +}; +static void print_VkCommandPoolCreateFlagBits(VkCommandPoolCreateFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkCommandPoolCreateFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkCommandPoolCreateFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkCommandPoolCreateFlagBits(const VkCommandPoolCreateFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkCommandPoolCreateFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkCommandPoolCreateFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkCommandPoolResetFlagBits_map = { + std::make_pair(1ULL << 1, "VK_COMMAND_POOL_RESET_RESERVED_1_BIT_COREAVI"), +}; +static void print_VkCommandPoolResetFlagBits(VkCommandPoolResetFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkCommandPoolResetFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkCommandPoolResetFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkCommandPoolResetFlagBits(const VkCommandPoolResetFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkCommandPoolResetFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkCommandPoolResetFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkCommandBufferLevel_map = { + std::make_pair(0, "VK_COMMAND_BUFFER_LEVEL_PRIMARY"), + std::make_pair(1, "VK_COMMAND_BUFFER_LEVEL_SECONDARY"), +}; +static void print_VkCommandBufferLevel(VkCommandBufferLevel obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkCommandBufferLevel_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkCommandBufferLevel_map[obj] << "\"" << std::endl; +} +static void print_VkCommandBufferLevel(const VkCommandBufferLevel * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkCommandBufferLevel_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkCommandBufferLevel_map[*obj] << "\"" << std::endl; +} + +static std::map VkCommandBufferUsageFlagBits_map = { + std::make_pair(1ULL << 0, "VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT"), + std::make_pair(1ULL << 1, "VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT"), + std::make_pair(1ULL << 2, "VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT"), +}; +static void print_VkCommandBufferUsageFlagBits(VkCommandBufferUsageFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkCommandBufferUsageFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkCommandBufferUsageFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkCommandBufferUsageFlagBits(const VkCommandBufferUsageFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkCommandBufferUsageFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkCommandBufferUsageFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkQueryControlFlagBits_map = { + std::make_pair(1ULL << 0, "VK_QUERY_CONTROL_PRECISE_BIT"), +}; +static void print_VkQueryControlFlagBits(VkQueryControlFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkQueryControlFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkQueryControlFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkQueryControlFlagBits(const VkQueryControlFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkQueryControlFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkQueryControlFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkCommandBufferResetFlagBits_map = { + std::make_pair(1ULL << 0, "VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT"), +}; +static void print_VkCommandBufferResetFlagBits(VkCommandBufferResetFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkCommandBufferResetFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkCommandBufferResetFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkCommandBufferResetFlagBits(const VkCommandBufferResetFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkCommandBufferResetFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkCommandBufferResetFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkIndexType_map = { + std::make_pair(0, "VK_INDEX_TYPE_UINT16"), + std::make_pair(1, "VK_INDEX_TYPE_UINT32"), + std::make_pair(1000165000, "VK_INDEX_TYPE_NONE_KHR"), + std::make_pair(1000265000, "VK_INDEX_TYPE_UINT8_EXT"), +}; +static void print_VkIndexType(VkIndexType obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkIndexType_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkIndexType_map[obj] << "\"" << std::endl; +} +static void print_VkIndexType(const VkIndexType * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkIndexType_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkIndexType_map[*obj] << "\"" << std::endl; +} + +static std::map VkStencilFaceFlagBits_map = { + std::make_pair(1ULL << 0, "VK_STENCIL_FACE_FRONT_BIT"), + std::make_pair(1ULL << 1, "VK_STENCIL_FACE_BACK_BIT"), + std::make_pair(0x00000003, "VK_STENCIL_FACE_FRONT_AND_BACK"), +}; +static void print_VkStencilFaceFlagBits(VkStencilFaceFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkStencilFaceFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkStencilFaceFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkStencilFaceFlagBits(const VkStencilFaceFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkStencilFaceFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkStencilFaceFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkSubpassContents_map = { + std::make_pair(0, "VK_SUBPASS_CONTENTS_INLINE"), + std::make_pair(1, "VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS"), +}; +static void print_VkSubpassContents(VkSubpassContents obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSubpassContents_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSubpassContents_map[obj] << "\"" << std::endl; +} +static void print_VkSubpassContents(const VkSubpassContents * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSubpassContents_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSubpassContents_map[*obj] << "\"" << std::endl; +} + +static void print_VkAccessFlags(VkAccessFlags obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + const int max_bits = 64; // We don't expect the number to be larger. + std::bitset b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkAccessFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkAccessFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkImageAspectFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkImageAspectFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkFormatFeatureFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkFormatFeatureFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkImageCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkImageCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkSampleCountFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkSampleCountFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkImageUsageFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkImageUsageFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkMemoryHeapFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkMemoryHeapFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkMemoryPropertyFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkMemoryPropertyFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkQueueFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkQueueFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkDeviceQueueCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkDeviceQueueCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkPipelineStageFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkPipelineStageFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkFenceCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkFenceCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkEventCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkEventCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkQueryPipelineStatisticFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkQueryPipelineStatisticFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkQueryResultFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkQueryResultFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkBufferCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkBufferCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkBufferUsageFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkBufferUsageFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkImageViewCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkImageViewCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkPipelineCacheCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkPipelineCacheCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkColorComponentFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkColorComponentFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkPipelineCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkPipelineCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkPipelineShaderStageCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkPipelineShaderStageCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkCullModeFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkCullModeFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkShaderStageFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkShaderStageFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkSamplerCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkSamplerCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkDescriptorPoolCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkDescriptorPoolCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkDescriptorSetLayoutCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkDescriptorSetLayoutCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkAttachmentDescriptionFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkAttachmentDescriptionFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkDependencyFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkDependencyFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkFramebufferCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkFramebufferCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkRenderPassCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkRenderPassCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkSubpassDescriptionFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkSubpassDescriptionFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkCommandPoolCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkCommandPoolCreateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkCommandPoolResetFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkCommandPoolResetFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkCommandBufferUsageFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkCommandBufferUsageFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkQueryControlFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkQueryControlFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkCommandBufferResetFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkCommandBufferResetFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkStencilFaceFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkStencilFaceFlagBits_map[1ULL<width, "width", 1); + + print_uint32_t(obj->height, "height", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkExtent3D(VkExtent3D obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj.width, "width", 1); + + print_uint32_t(obj.height, "height", 1); + + print_uint32_t(obj.depth, "depth", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkExtent3D(const VkExtent3D * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj->width, "width", 1); + + print_uint32_t(obj->height, "height", 1); + + print_uint32_t(obj->depth, "depth", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkOffset2D(VkOffset2D obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_int32_t(obj.x, "x", 1); + + print_int32_t(obj.y, "y", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkOffset2D(const VkOffset2D * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_int32_t(obj->x, "x", 1); + + print_int32_t(obj->y, "y", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkOffset3D(VkOffset3D obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_int32_t(obj.x, "x", 1); + + print_int32_t(obj.y, "y", 1); + + print_int32_t(obj.z, "z", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkOffset3D(const VkOffset3D * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_int32_t(obj->x, "x", 1); + + print_int32_t(obj->y, "y", 1); + + print_int32_t(obj->z, "z", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkRect2D(VkRect2D obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"offset\": " << std::endl; + { + print_VkOffset2D(obj.offset, "offset", 1); + } + + PRINT_SPACE + _OUT << "\"extent\": " << std::endl; + { + print_VkExtent2D(obj.extent, "extent", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkRect2D(const VkRect2D * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"offset\": " << std::endl; + { + print_VkOffset2D(obj->offset, "offset", 1); + } + + PRINT_SPACE + _OUT << "\"extent\": " << std::endl; + { + print_VkExtent2D(obj->extent, "extent", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkBaseInStructure(VkBaseInStructure obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkBaseInStructure(const VkBaseInStructure * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkBaseOutStructure(VkBaseOutStructure obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkBaseOutStructure(const VkBaseOutStructure * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkBufferMemoryBarrier(VkBufferMemoryBarrier obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkAccessFlags(obj.srcAccessMask, "srcAccessMask", 1); + + print_VkAccessFlags(obj.dstAccessMask, "dstAccessMask", 1); + + print_uint32_t(obj.srcQueueFamilyIndex, "srcQueueFamilyIndex", 1); + + print_uint32_t(obj.dstQueueFamilyIndex, "dstQueueFamilyIndex", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkDeviceSize(obj.offset, "offset", 1); + + print_VkDeviceSize(obj.size, "size", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkBufferMemoryBarrier(const VkBufferMemoryBarrier * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkAccessFlags(obj->srcAccessMask, "srcAccessMask", 1); + + print_VkAccessFlags(obj->dstAccessMask, "dstAccessMask", 1); + + print_uint32_t(obj->srcQueueFamilyIndex, "srcQueueFamilyIndex", 1); + + print_uint32_t(obj->dstQueueFamilyIndex, "dstQueueFamilyIndex", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkDeviceSize(obj->offset, "offset", 1); + + print_VkDeviceSize(obj->size, "size", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDispatchIndirectCommand(VkDispatchIndirectCommand obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj.x, "x", 1); + + print_uint32_t(obj.y, "y", 1); + + print_uint32_t(obj.z, "z", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDispatchIndirectCommand(const VkDispatchIndirectCommand * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj->x, "x", 1); + + print_uint32_t(obj->y, "y", 1); + + print_uint32_t(obj->z, "z", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDrawIndexedIndirectCommand(VkDrawIndexedIndirectCommand obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj.indexCount, "indexCount", 1); + + print_uint32_t(obj.instanceCount, "instanceCount", 1); + + print_uint32_t(obj.firstIndex, "firstIndex", 1); + + print_int32_t(obj.vertexOffset, "vertexOffset", 1); + + print_uint32_t(obj.firstInstance, "firstInstance", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDrawIndexedIndirectCommand(const VkDrawIndexedIndirectCommand * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj->indexCount, "indexCount", 1); + + print_uint32_t(obj->instanceCount, "instanceCount", 1); + + print_uint32_t(obj->firstIndex, "firstIndex", 1); + + print_int32_t(obj->vertexOffset, "vertexOffset", 1); + + print_uint32_t(obj->firstInstance, "firstInstance", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDrawIndirectCommand(VkDrawIndirectCommand obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj.vertexCount, "vertexCount", 1); + + print_uint32_t(obj.instanceCount, "instanceCount", 1); + + print_uint32_t(obj.firstVertex, "firstVertex", 1); + + print_uint32_t(obj.firstInstance, "firstInstance", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDrawIndirectCommand(const VkDrawIndirectCommand * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj->vertexCount, "vertexCount", 1); + + print_uint32_t(obj->instanceCount, "instanceCount", 1); + + print_uint32_t(obj->firstVertex, "firstVertex", 1); + + print_uint32_t(obj->firstInstance, "firstInstance", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageSubresourceRange(VkImageSubresourceRange obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkImageAspectFlags(obj.aspectMask, "aspectMask", 1); + + print_uint32_t(obj.baseMipLevel, "baseMipLevel", 1); + + print_uint32_t(obj.levelCount, "levelCount", 1); + + print_uint32_t(obj.baseArrayLayer, "baseArrayLayer", 1); + + print_uint32_t(obj.layerCount, "layerCount", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageSubresourceRange(const VkImageSubresourceRange * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkImageAspectFlags(obj->aspectMask, "aspectMask", 1); + + print_uint32_t(obj->baseMipLevel, "baseMipLevel", 1); + + print_uint32_t(obj->levelCount, "levelCount", 1); + + print_uint32_t(obj->baseArrayLayer, "baseArrayLayer", 1); + + print_uint32_t(obj->layerCount, "layerCount", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageMemoryBarrier(VkImageMemoryBarrier obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkAccessFlags(obj.srcAccessMask, "srcAccessMask", 1); + + print_VkAccessFlags(obj.dstAccessMask, "dstAccessMask", 1); + + print_VkImageLayout(obj.oldLayout, "oldLayout", 1); + + print_VkImageLayout(obj.newLayout, "newLayout", 1); + + print_uint32_t(obj.srcQueueFamilyIndex, "srcQueueFamilyIndex", 1); + + print_uint32_t(obj.dstQueueFamilyIndex, "dstQueueFamilyIndex", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"," << std::endl; + + PRINT_SPACE + _OUT << "\"subresourceRange\": " << std::endl; + { + print_VkImageSubresourceRange(obj.subresourceRange, "subresourceRange", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageMemoryBarrier(const VkImageMemoryBarrier * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkAccessFlags(obj->srcAccessMask, "srcAccessMask", 1); + + print_VkAccessFlags(obj->dstAccessMask, "dstAccessMask", 1); + + print_VkImageLayout(obj->oldLayout, "oldLayout", 1); + + print_VkImageLayout(obj->newLayout, "newLayout", 1); + + print_uint32_t(obj->srcQueueFamilyIndex, "srcQueueFamilyIndex", 1); + + print_uint32_t(obj->dstQueueFamilyIndex, "dstQueueFamilyIndex", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"," << std::endl; + + PRINT_SPACE + _OUT << "\"subresourceRange\": " << std::endl; + { + print_VkImageSubresourceRange(obj->subresourceRange, "subresourceRange", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkMemoryBarrier(VkMemoryBarrier obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkAccessFlags(obj.srcAccessMask, "srcAccessMask", 1); + + print_VkAccessFlags(obj.dstAccessMask, "dstAccessMask", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkMemoryBarrier(const VkMemoryBarrier * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkAccessFlags(obj->srcAccessMask, "srcAccessMask", 1); + + print_VkAccessFlags(obj->dstAccessMask, "dstAccessMask", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineCacheHeaderVersionOne(VkPipelineCacheHeaderVersionOne obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj.headerSize, "headerSize", 1); + + print_VkPipelineCacheHeaderVersion(obj.headerVersion, "headerVersion", 1); + + print_uint32_t(obj.vendorID, "vendorID", 1); + + print_uint32_t(obj.deviceID, "deviceID", 1); + + PRINT_SPACE + _OUT << "\"pipelineCacheUUID\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_UUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_UUID_SIZE; + print_uint8_t(obj.pipelineCacheUUID[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineCacheHeaderVersionOne(const VkPipelineCacheHeaderVersionOne * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj->headerSize, "headerSize", 1); + + print_VkPipelineCacheHeaderVersion(obj->headerVersion, "headerVersion", 1); + + print_uint32_t(obj->vendorID, "vendorID", 1); + + print_uint32_t(obj->deviceID, "deviceID", 1); + + PRINT_SPACE + _OUT << "\"pipelineCacheUUID\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_UUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_UUID_SIZE; + print_uint8_t(obj->pipelineCacheUUID[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkAllocationCallbacks(VkAllocationCallbacks obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + /** Note: Ignoring void* data. **/ + + /** Note: Ignoring function pointer (PFN_vkAllocationFunction). **/ + + /** Note: Ignoring function pointer (PFN_vkReallocationFunction). **/ + + /** Note: Ignoring function pointer (PFN_vkFreeFunction). **/ + + /** Note: Ignoring function pointer (PFN_vkInternalAllocationNotification). **/ + + /** Note: Ignoring function pointer (PFN_vkInternalFreeNotification). **/ + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkAllocationCallbacks(const VkAllocationCallbacks * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + /** Note: Ignoring void* data. **/ + + /** Note: Ignoring function pointer (PFN_vkAllocationFunction). **/ + + /** Note: Ignoring function pointer (PFN_vkReallocationFunction). **/ + + /** Note: Ignoring function pointer (PFN_vkFreeFunction). **/ + + /** Note: Ignoring function pointer (PFN_vkInternalAllocationNotification). **/ + + /** Note: Ignoring function pointer (PFN_vkInternalFreeNotification). **/ + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkApplicationInfo(VkApplicationInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_char(obj.pApplicationName, "pApplicationName", 1); + + print_uint32_t(obj.applicationVersion, "applicationVersion", 1); + + print_char(obj.pEngineName, "pEngineName", 1); + + print_uint32_t(obj.engineVersion, "engineVersion", 1); + + print_uint32_t(obj.apiVersion, "apiVersion", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkApplicationInfo(const VkApplicationInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_char(obj->pApplicationName, "pApplicationName", 1); + + print_uint32_t(obj->applicationVersion, "applicationVersion", 1); + + print_char(obj->pEngineName, "pEngineName", 1); + + print_uint32_t(obj->engineVersion, "engineVersion", 1); + + print_uint32_t(obj->apiVersion, "apiVersion", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkFormatProperties(VkFormatProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkFormatFeatureFlags(obj.linearTilingFeatures, "linearTilingFeatures", 1); + + print_VkFormatFeatureFlags(obj.optimalTilingFeatures, "optimalTilingFeatures", 1); + + print_VkFormatFeatureFlags(obj.bufferFeatures, "bufferFeatures", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkFormatProperties(const VkFormatProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkFormatFeatureFlags(obj->linearTilingFeatures, "linearTilingFeatures", 1); + + print_VkFormatFeatureFlags(obj->optimalTilingFeatures, "optimalTilingFeatures", 1); + + print_VkFormatFeatureFlags(obj->bufferFeatures, "bufferFeatures", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageFormatProperties(VkImageFormatProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"maxExtent\": " << std::endl; + { + print_VkExtent3D(obj.maxExtent, "maxExtent", 1); + } + + print_uint32_t(obj.maxMipLevels, "maxMipLevels", 1); + + print_uint32_t(obj.maxArrayLayers, "maxArrayLayers", 1); + + print_VkSampleCountFlags(obj.sampleCounts, "sampleCounts", 1); + + print_VkDeviceSize(obj.maxResourceSize, "maxResourceSize", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageFormatProperties(const VkImageFormatProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"maxExtent\": " << std::endl; + { + print_VkExtent3D(obj->maxExtent, "maxExtent", 1); + } + + print_uint32_t(obj->maxMipLevels, "maxMipLevels", 1); + + print_uint32_t(obj->maxArrayLayers, "maxArrayLayers", 1); + + print_VkSampleCountFlags(obj->sampleCounts, "sampleCounts", 1); + + print_VkDeviceSize(obj->maxResourceSize, "maxResourceSize", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkInstanceCreateInfo(VkInstanceCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkInstanceCreateFlags(obj.flags, "flags", 1); + + PRINT_SPACE + _OUT << "\"pApplicationInfo\": " << std::endl; + if (obj.pApplicationInfo) { + print_VkApplicationInfo(obj.pApplicationInfo, "pApplicationInfo", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.enabledLayerCount, "enabledLayerCount", 1); + + print_char(obj.ppEnabledLayerNames, "ppEnabledLayerNames", 1); + + print_uint32_t(obj.enabledExtensionCount, "enabledExtensionCount", 1); + + print_char(obj.ppEnabledExtensionNames, "ppEnabledExtensionNames", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkInstanceCreateInfo(const VkInstanceCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkInstanceCreateFlags(obj->flags, "flags", 1); + + PRINT_SPACE + _OUT << "\"pApplicationInfo\": " << std::endl; + if (obj->pApplicationInfo) { + print_VkApplicationInfo(obj->pApplicationInfo, "pApplicationInfo", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->enabledLayerCount, "enabledLayerCount", 1); + + print_char(obj->ppEnabledLayerNames, "ppEnabledLayerNames", 1); + + print_uint32_t(obj->enabledExtensionCount, "enabledExtensionCount", 1); + + print_char(obj->ppEnabledExtensionNames, "ppEnabledExtensionNames", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkMemoryHeap(VkMemoryHeap obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkDeviceSize(obj.size, "size", 1); + + print_VkMemoryHeapFlags(obj.flags, "flags", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkMemoryHeap(const VkMemoryHeap * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkDeviceSize(obj->size, "size", 1); + + print_VkMemoryHeapFlags(obj->flags, "flags", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkMemoryType(VkMemoryType obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkMemoryPropertyFlags(obj.propertyFlags, "propertyFlags", 1); + + print_uint32_t(obj.heapIndex, "heapIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkMemoryType(const VkMemoryType * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkMemoryPropertyFlags(obj->propertyFlags, "propertyFlags", 1); + + print_uint32_t(obj->heapIndex, "heapIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceFeatures(VkPhysicalDeviceFeatures obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkBool32(obj.robustBufferAccess, "robustBufferAccess", 1); + + print_VkBool32(obj.fullDrawIndexUint32, "fullDrawIndexUint32", 1); + + print_VkBool32(obj.imageCubeArray, "imageCubeArray", 1); + + print_VkBool32(obj.independentBlend, "independentBlend", 1); + + print_VkBool32(obj.geometryShader, "geometryShader", 1); + + print_VkBool32(obj.tessellationShader, "tessellationShader", 1); + + print_VkBool32(obj.sampleRateShading, "sampleRateShading", 1); + + print_VkBool32(obj.dualSrcBlend, "dualSrcBlend", 1); + + print_VkBool32(obj.logicOp, "logicOp", 1); + + print_VkBool32(obj.multiDrawIndirect, "multiDrawIndirect", 1); + + print_VkBool32(obj.drawIndirectFirstInstance, "drawIndirectFirstInstance", 1); + + print_VkBool32(obj.depthClamp, "depthClamp", 1); + + print_VkBool32(obj.depthBiasClamp, "depthBiasClamp", 1); + + print_VkBool32(obj.fillModeNonSolid, "fillModeNonSolid", 1); + + print_VkBool32(obj.depthBounds, "depthBounds", 1); + + print_VkBool32(obj.wideLines, "wideLines", 1); + + print_VkBool32(obj.largePoints, "largePoints", 1); + + print_VkBool32(obj.alphaToOne, "alphaToOne", 1); + + print_VkBool32(obj.multiViewport, "multiViewport", 1); + + print_VkBool32(obj.samplerAnisotropy, "samplerAnisotropy", 1); + + print_VkBool32(obj.textureCompressionETC2, "textureCompressionETC2", 1); + + print_VkBool32(obj.textureCompressionASTC_LDR, "textureCompressionASTC_LDR", 1); + + print_VkBool32(obj.textureCompressionBC, "textureCompressionBC", 1); + + print_VkBool32(obj.occlusionQueryPrecise, "occlusionQueryPrecise", 1); + + print_VkBool32(obj.pipelineStatisticsQuery, "pipelineStatisticsQuery", 1); + + print_VkBool32(obj.vertexPipelineStoresAndAtomics, "vertexPipelineStoresAndAtomics", 1); + + print_VkBool32(obj.fragmentStoresAndAtomics, "fragmentStoresAndAtomics", 1); + + print_VkBool32(obj.shaderTessellationAndGeometryPointSize, "shaderTessellationAndGeometryPointSize", 1); + + print_VkBool32(obj.shaderImageGatherExtended, "shaderImageGatherExtended", 1); + + print_VkBool32(obj.shaderStorageImageExtendedFormats, "shaderStorageImageExtendedFormats", 1); + + print_VkBool32(obj.shaderStorageImageMultisample, "shaderStorageImageMultisample", 1); + + print_VkBool32(obj.shaderStorageImageReadWithoutFormat, "shaderStorageImageReadWithoutFormat", 1); + + print_VkBool32(obj.shaderStorageImageWriteWithoutFormat, "shaderStorageImageWriteWithoutFormat", 1); + + print_VkBool32(obj.shaderUniformBufferArrayDynamicIndexing, "shaderUniformBufferArrayDynamicIndexing", 1); + + print_VkBool32(obj.shaderSampledImageArrayDynamicIndexing, "shaderSampledImageArrayDynamicIndexing", 1); + + print_VkBool32(obj.shaderStorageBufferArrayDynamicIndexing, "shaderStorageBufferArrayDynamicIndexing", 1); + + print_VkBool32(obj.shaderStorageImageArrayDynamicIndexing, "shaderStorageImageArrayDynamicIndexing", 1); + + print_VkBool32(obj.shaderClipDistance, "shaderClipDistance", 1); + + print_VkBool32(obj.shaderCullDistance, "shaderCullDistance", 1); + + print_VkBool32(obj.shaderFloat64, "shaderFloat64", 1); + + print_VkBool32(obj.shaderInt64, "shaderInt64", 1); + + print_VkBool32(obj.shaderInt16, "shaderInt16", 1); + + print_VkBool32(obj.shaderResourceResidency, "shaderResourceResidency", 1); + + print_VkBool32(obj.shaderResourceMinLod, "shaderResourceMinLod", 1); + + print_VkBool32(obj.sparseBinding, "sparseBinding", 1); + + print_VkBool32(obj.sparseResidencyBuffer, "sparseResidencyBuffer", 1); + + print_VkBool32(obj.sparseResidencyImage2D, "sparseResidencyImage2D", 1); + + print_VkBool32(obj.sparseResidencyImage3D, "sparseResidencyImage3D", 1); + + print_VkBool32(obj.sparseResidency2Samples, "sparseResidency2Samples", 1); + + print_VkBool32(obj.sparseResidency4Samples, "sparseResidency4Samples", 1); + + print_VkBool32(obj.sparseResidency8Samples, "sparseResidency8Samples", 1); + + print_VkBool32(obj.sparseResidency16Samples, "sparseResidency16Samples", 1); + + print_VkBool32(obj.sparseResidencyAliased, "sparseResidencyAliased", 1); + + print_VkBool32(obj.variableMultisampleRate, "variableMultisampleRate", 1); + + print_VkBool32(obj.inheritedQueries, "inheritedQueries", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceFeatures(const VkPhysicalDeviceFeatures * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkBool32(obj->robustBufferAccess, "robustBufferAccess", 1); + + print_VkBool32(obj->fullDrawIndexUint32, "fullDrawIndexUint32", 1); + + print_VkBool32(obj->imageCubeArray, "imageCubeArray", 1); + + print_VkBool32(obj->independentBlend, "independentBlend", 1); + + print_VkBool32(obj->geometryShader, "geometryShader", 1); + + print_VkBool32(obj->tessellationShader, "tessellationShader", 1); + + print_VkBool32(obj->sampleRateShading, "sampleRateShading", 1); + + print_VkBool32(obj->dualSrcBlend, "dualSrcBlend", 1); + + print_VkBool32(obj->logicOp, "logicOp", 1); + + print_VkBool32(obj->multiDrawIndirect, "multiDrawIndirect", 1); + + print_VkBool32(obj->drawIndirectFirstInstance, "drawIndirectFirstInstance", 1); + + print_VkBool32(obj->depthClamp, "depthClamp", 1); + + print_VkBool32(obj->depthBiasClamp, "depthBiasClamp", 1); + + print_VkBool32(obj->fillModeNonSolid, "fillModeNonSolid", 1); + + print_VkBool32(obj->depthBounds, "depthBounds", 1); + + print_VkBool32(obj->wideLines, "wideLines", 1); + + print_VkBool32(obj->largePoints, "largePoints", 1); + + print_VkBool32(obj->alphaToOne, "alphaToOne", 1); + + print_VkBool32(obj->multiViewport, "multiViewport", 1); + + print_VkBool32(obj->samplerAnisotropy, "samplerAnisotropy", 1); + + print_VkBool32(obj->textureCompressionETC2, "textureCompressionETC2", 1); + + print_VkBool32(obj->textureCompressionASTC_LDR, "textureCompressionASTC_LDR", 1); + + print_VkBool32(obj->textureCompressionBC, "textureCompressionBC", 1); + + print_VkBool32(obj->occlusionQueryPrecise, "occlusionQueryPrecise", 1); + + print_VkBool32(obj->pipelineStatisticsQuery, "pipelineStatisticsQuery", 1); + + print_VkBool32(obj->vertexPipelineStoresAndAtomics, "vertexPipelineStoresAndAtomics", 1); + + print_VkBool32(obj->fragmentStoresAndAtomics, "fragmentStoresAndAtomics", 1); + + print_VkBool32(obj->shaderTessellationAndGeometryPointSize, "shaderTessellationAndGeometryPointSize", 1); + + print_VkBool32(obj->shaderImageGatherExtended, "shaderImageGatherExtended", 1); + + print_VkBool32(obj->shaderStorageImageExtendedFormats, "shaderStorageImageExtendedFormats", 1); + + print_VkBool32(obj->shaderStorageImageMultisample, "shaderStorageImageMultisample", 1); + + print_VkBool32(obj->shaderStorageImageReadWithoutFormat, "shaderStorageImageReadWithoutFormat", 1); + + print_VkBool32(obj->shaderStorageImageWriteWithoutFormat, "shaderStorageImageWriteWithoutFormat", 1); + + print_VkBool32(obj->shaderUniformBufferArrayDynamicIndexing, "shaderUniformBufferArrayDynamicIndexing", 1); + + print_VkBool32(obj->shaderSampledImageArrayDynamicIndexing, "shaderSampledImageArrayDynamicIndexing", 1); + + print_VkBool32(obj->shaderStorageBufferArrayDynamicIndexing, "shaderStorageBufferArrayDynamicIndexing", 1); + + print_VkBool32(obj->shaderStorageImageArrayDynamicIndexing, "shaderStorageImageArrayDynamicIndexing", 1); + + print_VkBool32(obj->shaderClipDistance, "shaderClipDistance", 1); + + print_VkBool32(obj->shaderCullDistance, "shaderCullDistance", 1); + + print_VkBool32(obj->shaderFloat64, "shaderFloat64", 1); + + print_VkBool32(obj->shaderInt64, "shaderInt64", 1); + + print_VkBool32(obj->shaderInt16, "shaderInt16", 1); + + print_VkBool32(obj->shaderResourceResidency, "shaderResourceResidency", 1); + + print_VkBool32(obj->shaderResourceMinLod, "shaderResourceMinLod", 1); + + print_VkBool32(obj->sparseBinding, "sparseBinding", 1); + + print_VkBool32(obj->sparseResidencyBuffer, "sparseResidencyBuffer", 1); + + print_VkBool32(obj->sparseResidencyImage2D, "sparseResidencyImage2D", 1); + + print_VkBool32(obj->sparseResidencyImage3D, "sparseResidencyImage3D", 1); + + print_VkBool32(obj->sparseResidency2Samples, "sparseResidency2Samples", 1); + + print_VkBool32(obj->sparseResidency4Samples, "sparseResidency4Samples", 1); + + print_VkBool32(obj->sparseResidency8Samples, "sparseResidency8Samples", 1); + + print_VkBool32(obj->sparseResidency16Samples, "sparseResidency16Samples", 1); + + print_VkBool32(obj->sparseResidencyAliased, "sparseResidencyAliased", 1); + + print_VkBool32(obj->variableMultisampleRate, "variableMultisampleRate", 1); + + print_VkBool32(obj->inheritedQueries, "inheritedQueries", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceLimits(VkPhysicalDeviceLimits obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj.maxImageDimension1D, "maxImageDimension1D", 1); + + print_uint32_t(obj.maxImageDimension2D, "maxImageDimension2D", 1); + + print_uint32_t(obj.maxImageDimension3D, "maxImageDimension3D", 1); + + print_uint32_t(obj.maxImageDimensionCube, "maxImageDimensionCube", 1); + + print_uint32_t(obj.maxImageArrayLayers, "maxImageArrayLayers", 1); + + print_uint32_t(obj.maxTexelBufferElements, "maxTexelBufferElements", 1); + + print_uint32_t(obj.maxUniformBufferRange, "maxUniformBufferRange", 1); + + print_uint32_t(obj.maxStorageBufferRange, "maxStorageBufferRange", 1); + + print_uint32_t(obj.maxPushConstantsSize, "maxPushConstantsSize", 1); + + print_uint32_t(obj.maxMemoryAllocationCount, "maxMemoryAllocationCount", 1); + + print_uint32_t(obj.maxSamplerAllocationCount, "maxSamplerAllocationCount", 1); + + print_VkDeviceSize(obj.bufferImageGranularity, "bufferImageGranularity", 1); + + print_VkDeviceSize(obj.sparseAddressSpaceSize, "sparseAddressSpaceSize", 1); + + print_uint32_t(obj.maxBoundDescriptorSets, "maxBoundDescriptorSets", 1); + + print_uint32_t(obj.maxPerStageDescriptorSamplers, "maxPerStageDescriptorSamplers", 1); + + print_uint32_t(obj.maxPerStageDescriptorUniformBuffers, "maxPerStageDescriptorUniformBuffers", 1); + + print_uint32_t(obj.maxPerStageDescriptorStorageBuffers, "maxPerStageDescriptorStorageBuffers", 1); + + print_uint32_t(obj.maxPerStageDescriptorSampledImages, "maxPerStageDescriptorSampledImages", 1); + + print_uint32_t(obj.maxPerStageDescriptorStorageImages, "maxPerStageDescriptorStorageImages", 1); + + print_uint32_t(obj.maxPerStageDescriptorInputAttachments, "maxPerStageDescriptorInputAttachments", 1); + + print_uint32_t(obj.maxPerStageResources, "maxPerStageResources", 1); + + print_uint32_t(obj.maxDescriptorSetSamplers, "maxDescriptorSetSamplers", 1); + + print_uint32_t(obj.maxDescriptorSetUniformBuffers, "maxDescriptorSetUniformBuffers", 1); + + print_uint32_t(obj.maxDescriptorSetUniformBuffersDynamic, "maxDescriptorSetUniformBuffersDynamic", 1); + + print_uint32_t(obj.maxDescriptorSetStorageBuffers, "maxDescriptorSetStorageBuffers", 1); + + print_uint32_t(obj.maxDescriptorSetStorageBuffersDynamic, "maxDescriptorSetStorageBuffersDynamic", 1); + + print_uint32_t(obj.maxDescriptorSetSampledImages, "maxDescriptorSetSampledImages", 1); + + print_uint32_t(obj.maxDescriptorSetStorageImages, "maxDescriptorSetStorageImages", 1); + + print_uint32_t(obj.maxDescriptorSetInputAttachments, "maxDescriptorSetInputAttachments", 1); + + print_uint32_t(obj.maxVertexInputAttributes, "maxVertexInputAttributes", 1); + + print_uint32_t(obj.maxVertexInputBindings, "maxVertexInputBindings", 1); + + print_uint32_t(obj.maxVertexInputAttributeOffset, "maxVertexInputAttributeOffset", 1); + + print_uint32_t(obj.maxVertexInputBindingStride, "maxVertexInputBindingStride", 1); + + print_uint32_t(obj.maxVertexOutputComponents, "maxVertexOutputComponents", 1); + + print_uint32_t(obj.maxTessellationGenerationLevel, "maxTessellationGenerationLevel", 1); + + print_uint32_t(obj.maxTessellationPatchSize, "maxTessellationPatchSize", 1); + + print_uint32_t(obj.maxTessellationControlPerVertexInputComponents, "maxTessellationControlPerVertexInputComponents", 1); + + print_uint32_t(obj.maxTessellationControlPerVertexOutputComponents, "maxTessellationControlPerVertexOutputComponents", 1); + + print_uint32_t(obj.maxTessellationControlPerPatchOutputComponents, "maxTessellationControlPerPatchOutputComponents", 1); + + print_uint32_t(obj.maxTessellationControlTotalOutputComponents, "maxTessellationControlTotalOutputComponents", 1); + + print_uint32_t(obj.maxTessellationEvaluationInputComponents, "maxTessellationEvaluationInputComponents", 1); + + print_uint32_t(obj.maxTessellationEvaluationOutputComponents, "maxTessellationEvaluationOutputComponents", 1); + + print_uint32_t(obj.maxGeometryShaderInvocations, "maxGeometryShaderInvocations", 1); + + print_uint32_t(obj.maxGeometryInputComponents, "maxGeometryInputComponents", 1); + + print_uint32_t(obj.maxGeometryOutputComponents, "maxGeometryOutputComponents", 1); + + print_uint32_t(obj.maxGeometryOutputVertices, "maxGeometryOutputVertices", 1); + + print_uint32_t(obj.maxGeometryTotalOutputComponents, "maxGeometryTotalOutputComponents", 1); + + print_uint32_t(obj.maxFragmentInputComponents, "maxFragmentInputComponents", 1); + + print_uint32_t(obj.maxFragmentOutputAttachments, "maxFragmentOutputAttachments", 1); + + print_uint32_t(obj.maxFragmentDualSrcAttachments, "maxFragmentDualSrcAttachments", 1); + + print_uint32_t(obj.maxFragmentCombinedOutputResources, "maxFragmentCombinedOutputResources", 1); + + print_uint32_t(obj.maxComputeSharedMemorySize, "maxComputeSharedMemorySize", 1); + + PRINT_SPACE + _OUT << "\"maxComputeWorkGroupCount\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 3; i++) { + bool isCommaNeeded = (i+1) != 3; + print_uint32_t(obj.maxComputeWorkGroupCount[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_uint32_t(obj.maxComputeWorkGroupInvocations, "maxComputeWorkGroupInvocations", 1); + + PRINT_SPACE + _OUT << "\"maxComputeWorkGroupSize\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 3; i++) { + bool isCommaNeeded = (i+1) != 3; + print_uint32_t(obj.maxComputeWorkGroupSize[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_uint32_t(obj.subPixelPrecisionBits, "subPixelPrecisionBits", 1); + + print_uint32_t(obj.subTexelPrecisionBits, "subTexelPrecisionBits", 1); + + print_uint32_t(obj.mipmapPrecisionBits, "mipmapPrecisionBits", 1); + + print_uint32_t(obj.maxDrawIndexedIndexValue, "maxDrawIndexedIndexValue", 1); + + print_uint32_t(obj.maxDrawIndirectCount, "maxDrawIndirectCount", 1); + + print_float(obj.maxSamplerLodBias, "maxSamplerLodBias", 1); + + print_float(obj.maxSamplerAnisotropy, "maxSamplerAnisotropy", 1); + + print_uint32_t(obj.maxViewports, "maxViewports", 1); + + PRINT_SPACE + _OUT << "\"maxViewportDimensions\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 2; i++) { + bool isCommaNeeded = (i+1) != 2; + print_uint32_t(obj.maxViewportDimensions[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"viewportBoundsRange\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 2; i++) { + bool isCommaNeeded = (i+1) != 2; + print_float(obj.viewportBoundsRange[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_uint32_t(obj.viewportSubPixelBits, "viewportSubPixelBits", 1); + + print_size_t(obj.minMemoryMapAlignment, "minMemoryMapAlignment", 1); + + print_VkDeviceSize(obj.minTexelBufferOffsetAlignment, "minTexelBufferOffsetAlignment", 1); + + print_VkDeviceSize(obj.minUniformBufferOffsetAlignment, "minUniformBufferOffsetAlignment", 1); + + print_VkDeviceSize(obj.minStorageBufferOffsetAlignment, "minStorageBufferOffsetAlignment", 1); + + print_int32_t(obj.minTexelOffset, "minTexelOffset", 1); + + print_uint32_t(obj.maxTexelOffset, "maxTexelOffset", 1); + + print_int32_t(obj.minTexelGatherOffset, "minTexelGatherOffset", 1); + + print_uint32_t(obj.maxTexelGatherOffset, "maxTexelGatherOffset", 1); + + print_float(obj.minInterpolationOffset, "minInterpolationOffset", 1); + + print_float(obj.maxInterpolationOffset, "maxInterpolationOffset", 1); + + print_uint32_t(obj.subPixelInterpolationOffsetBits, "subPixelInterpolationOffsetBits", 1); + + print_uint32_t(obj.maxFramebufferWidth, "maxFramebufferWidth", 1); + + print_uint32_t(obj.maxFramebufferHeight, "maxFramebufferHeight", 1); + + print_uint32_t(obj.maxFramebufferLayers, "maxFramebufferLayers", 1); + + print_VkSampleCountFlags(obj.framebufferColorSampleCounts, "framebufferColorSampleCounts", 1); + + print_VkSampleCountFlags(obj.framebufferDepthSampleCounts, "framebufferDepthSampleCounts", 1); + + print_VkSampleCountFlags(obj.framebufferStencilSampleCounts, "framebufferStencilSampleCounts", 1); + + print_VkSampleCountFlags(obj.framebufferNoAttachmentsSampleCounts, "framebufferNoAttachmentsSampleCounts", 1); + + print_uint32_t(obj.maxColorAttachments, "maxColorAttachments", 1); + + print_VkSampleCountFlags(obj.sampledImageColorSampleCounts, "sampledImageColorSampleCounts", 1); + + print_VkSampleCountFlags(obj.sampledImageIntegerSampleCounts, "sampledImageIntegerSampleCounts", 1); + + print_VkSampleCountFlags(obj.sampledImageDepthSampleCounts, "sampledImageDepthSampleCounts", 1); + + print_VkSampleCountFlags(obj.sampledImageStencilSampleCounts, "sampledImageStencilSampleCounts", 1); + + print_VkSampleCountFlags(obj.storageImageSampleCounts, "storageImageSampleCounts", 1); + + print_uint32_t(obj.maxSampleMaskWords, "maxSampleMaskWords", 1); + + print_VkBool32(obj.timestampComputeAndGraphics, "timestampComputeAndGraphics", 1); + + print_float(obj.timestampPeriod, "timestampPeriod", 1); + + print_uint32_t(obj.maxClipDistances, "maxClipDistances", 1); + + print_uint32_t(obj.maxCullDistances, "maxCullDistances", 1); + + print_uint32_t(obj.maxCombinedClipAndCullDistances, "maxCombinedClipAndCullDistances", 1); + + print_uint32_t(obj.discreteQueuePriorities, "discreteQueuePriorities", 1); + + PRINT_SPACE + _OUT << "\"pointSizeRange\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 2; i++) { + bool isCommaNeeded = (i+1) != 2; + print_float(obj.pointSizeRange[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"lineWidthRange\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 2; i++) { + bool isCommaNeeded = (i+1) != 2; + print_float(obj.lineWidthRange[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_float(obj.pointSizeGranularity, "pointSizeGranularity", 1); + + print_float(obj.lineWidthGranularity, "lineWidthGranularity", 1); + + print_VkBool32(obj.strictLines, "strictLines", 1); + + print_VkBool32(obj.standardSampleLocations, "standardSampleLocations", 1); + + print_VkDeviceSize(obj.optimalBufferCopyOffsetAlignment, "optimalBufferCopyOffsetAlignment", 1); + + print_VkDeviceSize(obj.optimalBufferCopyRowPitchAlignment, "optimalBufferCopyRowPitchAlignment", 1); + + print_VkDeviceSize(obj.nonCoherentAtomSize, "nonCoherentAtomSize", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceLimits(const VkPhysicalDeviceLimits * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj->maxImageDimension1D, "maxImageDimension1D", 1); + + print_uint32_t(obj->maxImageDimension2D, "maxImageDimension2D", 1); + + print_uint32_t(obj->maxImageDimension3D, "maxImageDimension3D", 1); + + print_uint32_t(obj->maxImageDimensionCube, "maxImageDimensionCube", 1); + + print_uint32_t(obj->maxImageArrayLayers, "maxImageArrayLayers", 1); + + print_uint32_t(obj->maxTexelBufferElements, "maxTexelBufferElements", 1); + + print_uint32_t(obj->maxUniformBufferRange, "maxUniformBufferRange", 1); + + print_uint32_t(obj->maxStorageBufferRange, "maxStorageBufferRange", 1); + + print_uint32_t(obj->maxPushConstantsSize, "maxPushConstantsSize", 1); + + print_uint32_t(obj->maxMemoryAllocationCount, "maxMemoryAllocationCount", 1); + + print_uint32_t(obj->maxSamplerAllocationCount, "maxSamplerAllocationCount", 1); + + print_VkDeviceSize(obj->bufferImageGranularity, "bufferImageGranularity", 1); + + print_VkDeviceSize(obj->sparseAddressSpaceSize, "sparseAddressSpaceSize", 1); + + print_uint32_t(obj->maxBoundDescriptorSets, "maxBoundDescriptorSets", 1); + + print_uint32_t(obj->maxPerStageDescriptorSamplers, "maxPerStageDescriptorSamplers", 1); + + print_uint32_t(obj->maxPerStageDescriptorUniformBuffers, "maxPerStageDescriptorUniformBuffers", 1); + + print_uint32_t(obj->maxPerStageDescriptorStorageBuffers, "maxPerStageDescriptorStorageBuffers", 1); + + print_uint32_t(obj->maxPerStageDescriptorSampledImages, "maxPerStageDescriptorSampledImages", 1); + + print_uint32_t(obj->maxPerStageDescriptorStorageImages, "maxPerStageDescriptorStorageImages", 1); + + print_uint32_t(obj->maxPerStageDescriptorInputAttachments, "maxPerStageDescriptorInputAttachments", 1); + + print_uint32_t(obj->maxPerStageResources, "maxPerStageResources", 1); + + print_uint32_t(obj->maxDescriptorSetSamplers, "maxDescriptorSetSamplers", 1); + + print_uint32_t(obj->maxDescriptorSetUniformBuffers, "maxDescriptorSetUniformBuffers", 1); + + print_uint32_t(obj->maxDescriptorSetUniformBuffersDynamic, "maxDescriptorSetUniformBuffersDynamic", 1); + + print_uint32_t(obj->maxDescriptorSetStorageBuffers, "maxDescriptorSetStorageBuffers", 1); + + print_uint32_t(obj->maxDescriptorSetStorageBuffersDynamic, "maxDescriptorSetStorageBuffersDynamic", 1); + + print_uint32_t(obj->maxDescriptorSetSampledImages, "maxDescriptorSetSampledImages", 1); + + print_uint32_t(obj->maxDescriptorSetStorageImages, "maxDescriptorSetStorageImages", 1); + + print_uint32_t(obj->maxDescriptorSetInputAttachments, "maxDescriptorSetInputAttachments", 1); + + print_uint32_t(obj->maxVertexInputAttributes, "maxVertexInputAttributes", 1); + + print_uint32_t(obj->maxVertexInputBindings, "maxVertexInputBindings", 1); + + print_uint32_t(obj->maxVertexInputAttributeOffset, "maxVertexInputAttributeOffset", 1); + + print_uint32_t(obj->maxVertexInputBindingStride, "maxVertexInputBindingStride", 1); + + print_uint32_t(obj->maxVertexOutputComponents, "maxVertexOutputComponents", 1); + + print_uint32_t(obj->maxTessellationGenerationLevel, "maxTessellationGenerationLevel", 1); + + print_uint32_t(obj->maxTessellationPatchSize, "maxTessellationPatchSize", 1); + + print_uint32_t(obj->maxTessellationControlPerVertexInputComponents, "maxTessellationControlPerVertexInputComponents", 1); + + print_uint32_t(obj->maxTessellationControlPerVertexOutputComponents, "maxTessellationControlPerVertexOutputComponents", 1); + + print_uint32_t(obj->maxTessellationControlPerPatchOutputComponents, "maxTessellationControlPerPatchOutputComponents", 1); + + print_uint32_t(obj->maxTessellationControlTotalOutputComponents, "maxTessellationControlTotalOutputComponents", 1); + + print_uint32_t(obj->maxTessellationEvaluationInputComponents, "maxTessellationEvaluationInputComponents", 1); + + print_uint32_t(obj->maxTessellationEvaluationOutputComponents, "maxTessellationEvaluationOutputComponents", 1); + + print_uint32_t(obj->maxGeometryShaderInvocations, "maxGeometryShaderInvocations", 1); + + print_uint32_t(obj->maxGeometryInputComponents, "maxGeometryInputComponents", 1); + + print_uint32_t(obj->maxGeometryOutputComponents, "maxGeometryOutputComponents", 1); + + print_uint32_t(obj->maxGeometryOutputVertices, "maxGeometryOutputVertices", 1); + + print_uint32_t(obj->maxGeometryTotalOutputComponents, "maxGeometryTotalOutputComponents", 1); + + print_uint32_t(obj->maxFragmentInputComponents, "maxFragmentInputComponents", 1); + + print_uint32_t(obj->maxFragmentOutputAttachments, "maxFragmentOutputAttachments", 1); + + print_uint32_t(obj->maxFragmentDualSrcAttachments, "maxFragmentDualSrcAttachments", 1); + + print_uint32_t(obj->maxFragmentCombinedOutputResources, "maxFragmentCombinedOutputResources", 1); + + print_uint32_t(obj->maxComputeSharedMemorySize, "maxComputeSharedMemorySize", 1); + + PRINT_SPACE + _OUT << "\"maxComputeWorkGroupCount\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 3; i++) { + bool isCommaNeeded = (i+1) != 3; + print_uint32_t(obj->maxComputeWorkGroupCount[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_uint32_t(obj->maxComputeWorkGroupInvocations, "maxComputeWorkGroupInvocations", 1); + + PRINT_SPACE + _OUT << "\"maxComputeWorkGroupSize\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 3; i++) { + bool isCommaNeeded = (i+1) != 3; + print_uint32_t(obj->maxComputeWorkGroupSize[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_uint32_t(obj->subPixelPrecisionBits, "subPixelPrecisionBits", 1); + + print_uint32_t(obj->subTexelPrecisionBits, "subTexelPrecisionBits", 1); + + print_uint32_t(obj->mipmapPrecisionBits, "mipmapPrecisionBits", 1); + + print_uint32_t(obj->maxDrawIndexedIndexValue, "maxDrawIndexedIndexValue", 1); + + print_uint32_t(obj->maxDrawIndirectCount, "maxDrawIndirectCount", 1); + + print_float(obj->maxSamplerLodBias, "maxSamplerLodBias", 1); + + print_float(obj->maxSamplerAnisotropy, "maxSamplerAnisotropy", 1); + + print_uint32_t(obj->maxViewports, "maxViewports", 1); + + PRINT_SPACE + _OUT << "\"maxViewportDimensions\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 2; i++) { + bool isCommaNeeded = (i+1) != 2; + print_uint32_t(obj->maxViewportDimensions[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"viewportBoundsRange\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 2; i++) { + bool isCommaNeeded = (i+1) != 2; + print_float(obj->viewportBoundsRange[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_uint32_t(obj->viewportSubPixelBits, "viewportSubPixelBits", 1); + + print_size_t(obj->minMemoryMapAlignment, "minMemoryMapAlignment", 1); + + print_VkDeviceSize(obj->minTexelBufferOffsetAlignment, "minTexelBufferOffsetAlignment", 1); + + print_VkDeviceSize(obj->minUniformBufferOffsetAlignment, "minUniformBufferOffsetAlignment", 1); + + print_VkDeviceSize(obj->minStorageBufferOffsetAlignment, "minStorageBufferOffsetAlignment", 1); + + print_int32_t(obj->minTexelOffset, "minTexelOffset", 1); + + print_uint32_t(obj->maxTexelOffset, "maxTexelOffset", 1); + + print_int32_t(obj->minTexelGatherOffset, "minTexelGatherOffset", 1); + + print_uint32_t(obj->maxTexelGatherOffset, "maxTexelGatherOffset", 1); + + print_float(obj->minInterpolationOffset, "minInterpolationOffset", 1); + + print_float(obj->maxInterpolationOffset, "maxInterpolationOffset", 1); + + print_uint32_t(obj->subPixelInterpolationOffsetBits, "subPixelInterpolationOffsetBits", 1); + + print_uint32_t(obj->maxFramebufferWidth, "maxFramebufferWidth", 1); + + print_uint32_t(obj->maxFramebufferHeight, "maxFramebufferHeight", 1); + + print_uint32_t(obj->maxFramebufferLayers, "maxFramebufferLayers", 1); + + print_VkSampleCountFlags(obj->framebufferColorSampleCounts, "framebufferColorSampleCounts", 1); + + print_VkSampleCountFlags(obj->framebufferDepthSampleCounts, "framebufferDepthSampleCounts", 1); + + print_VkSampleCountFlags(obj->framebufferStencilSampleCounts, "framebufferStencilSampleCounts", 1); + + print_VkSampleCountFlags(obj->framebufferNoAttachmentsSampleCounts, "framebufferNoAttachmentsSampleCounts", 1); + + print_uint32_t(obj->maxColorAttachments, "maxColorAttachments", 1); + + print_VkSampleCountFlags(obj->sampledImageColorSampleCounts, "sampledImageColorSampleCounts", 1); + + print_VkSampleCountFlags(obj->sampledImageIntegerSampleCounts, "sampledImageIntegerSampleCounts", 1); + + print_VkSampleCountFlags(obj->sampledImageDepthSampleCounts, "sampledImageDepthSampleCounts", 1); + + print_VkSampleCountFlags(obj->sampledImageStencilSampleCounts, "sampledImageStencilSampleCounts", 1); + + print_VkSampleCountFlags(obj->storageImageSampleCounts, "storageImageSampleCounts", 1); + + print_uint32_t(obj->maxSampleMaskWords, "maxSampleMaskWords", 1); + + print_VkBool32(obj->timestampComputeAndGraphics, "timestampComputeAndGraphics", 1); + + print_float(obj->timestampPeriod, "timestampPeriod", 1); + + print_uint32_t(obj->maxClipDistances, "maxClipDistances", 1); + + print_uint32_t(obj->maxCullDistances, "maxCullDistances", 1); + + print_uint32_t(obj->maxCombinedClipAndCullDistances, "maxCombinedClipAndCullDistances", 1); + + print_uint32_t(obj->discreteQueuePriorities, "discreteQueuePriorities", 1); + + PRINT_SPACE + _OUT << "\"pointSizeRange\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 2; i++) { + bool isCommaNeeded = (i+1) != 2; + print_float(obj->pointSizeRange[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"lineWidthRange\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 2; i++) { + bool isCommaNeeded = (i+1) != 2; + print_float(obj->lineWidthRange[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_float(obj->pointSizeGranularity, "pointSizeGranularity", 1); + + print_float(obj->lineWidthGranularity, "lineWidthGranularity", 1); + + print_VkBool32(obj->strictLines, "strictLines", 1); + + print_VkBool32(obj->standardSampleLocations, "standardSampleLocations", 1); + + print_VkDeviceSize(obj->optimalBufferCopyOffsetAlignment, "optimalBufferCopyOffsetAlignment", 1); + + print_VkDeviceSize(obj->optimalBufferCopyRowPitchAlignment, "optimalBufferCopyRowPitchAlignment", 1); + + print_VkDeviceSize(obj->nonCoherentAtomSize, "nonCoherentAtomSize", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceMemoryProperties(VkPhysicalDeviceMemoryProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj.memoryTypeCount, "memoryTypeCount", 1); + + PRINT_SPACE + _OUT << "\"memoryTypes\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_MEMORY_TYPES; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_MEMORY_TYPES; + print_VkMemoryType(obj.memoryTypes[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_uint32_t(obj.memoryHeapCount, "memoryHeapCount", 1); + + PRINT_SPACE + _OUT << "\"memoryHeaps\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_MEMORY_HEAPS; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_MEMORY_HEAPS; + print_VkMemoryHeap(obj.memoryHeaps[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceMemoryProperties(const VkPhysicalDeviceMemoryProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj->memoryTypeCount, "memoryTypeCount", 1); + + PRINT_SPACE + _OUT << "\"memoryTypes\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_MEMORY_TYPES; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_MEMORY_TYPES; + print_VkMemoryType(obj->memoryTypes[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_uint32_t(obj->memoryHeapCount, "memoryHeapCount", 1); + + PRINT_SPACE + _OUT << "\"memoryHeaps\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_MEMORY_HEAPS; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_MEMORY_HEAPS; + print_VkMemoryHeap(obj->memoryHeaps[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceSparseProperties(VkPhysicalDeviceSparseProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkBool32(obj.residencyStandard2DBlockShape, "residencyStandard2DBlockShape", 1); + + print_VkBool32(obj.residencyStandard2DMultisampleBlockShape, "residencyStandard2DMultisampleBlockShape", 1); + + print_VkBool32(obj.residencyStandard3DBlockShape, "residencyStandard3DBlockShape", 1); + + print_VkBool32(obj.residencyAlignedMipSize, "residencyAlignedMipSize", 1); + + print_VkBool32(obj.residencyNonResidentStrict, "residencyNonResidentStrict", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceSparseProperties(const VkPhysicalDeviceSparseProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkBool32(obj->residencyStandard2DBlockShape, "residencyStandard2DBlockShape", 1); + + print_VkBool32(obj->residencyStandard2DMultisampleBlockShape, "residencyStandard2DMultisampleBlockShape", 1); + + print_VkBool32(obj->residencyStandard3DBlockShape, "residencyStandard3DBlockShape", 1); + + print_VkBool32(obj->residencyAlignedMipSize, "residencyAlignedMipSize", 1); + + print_VkBool32(obj->residencyNonResidentStrict, "residencyNonResidentStrict", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceProperties(VkPhysicalDeviceProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj.apiVersion, "apiVersion", 1); + + print_uint32_t(obj.driverVersion, "driverVersion", 1); + + print_uint32_t(obj.vendorID, "vendorID", 1); + + print_uint32_t(obj.deviceID, "deviceID", 1); + + print_VkPhysicalDeviceType(obj.deviceType, "deviceType", 1); + + PRINT_SPACE + _OUT << "\"deviceName\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; + print_char(obj.deviceName[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"pipelineCacheUUID\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_UUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_UUID_SIZE; + print_uint8_t(obj.pipelineCacheUUID[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"limits\": " << std::endl; + { + print_VkPhysicalDeviceLimits(obj.limits, "limits", 1); + } + + PRINT_SPACE + _OUT << "\"sparseProperties\": " << std::endl; + { + print_VkPhysicalDeviceSparseProperties(obj.sparseProperties, "sparseProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceProperties(const VkPhysicalDeviceProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj->apiVersion, "apiVersion", 1); + + print_uint32_t(obj->driverVersion, "driverVersion", 1); + + print_uint32_t(obj->vendorID, "vendorID", 1); + + print_uint32_t(obj->deviceID, "deviceID", 1); + + print_VkPhysicalDeviceType(obj->deviceType, "deviceType", 1); + + PRINT_SPACE + _OUT << "\"deviceName\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; + print_char(obj->deviceName[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"pipelineCacheUUID\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_UUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_UUID_SIZE; + print_uint8_t(obj->pipelineCacheUUID[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"limits\": " << std::endl; + { + print_VkPhysicalDeviceLimits(obj->limits, "limits", 1); + } + + PRINT_SPACE + _OUT << "\"sparseProperties\": " << std::endl; + { + print_VkPhysicalDeviceSparseProperties(obj->sparseProperties, "sparseProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkQueueFamilyProperties(VkQueueFamilyProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkQueueFlags(obj.queueFlags, "queueFlags", 1); + + print_uint32_t(obj.queueCount, "queueCount", 1); + + print_uint32_t(obj.timestampValidBits, "timestampValidBits", 1); + + PRINT_SPACE + _OUT << "\"minImageTransferGranularity\": " << std::endl; + { + print_VkExtent3D(obj.minImageTransferGranularity, "minImageTransferGranularity", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkQueueFamilyProperties(const VkQueueFamilyProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkQueueFlags(obj->queueFlags, "queueFlags", 1); + + print_uint32_t(obj->queueCount, "queueCount", 1); + + print_uint32_t(obj->timestampValidBits, "timestampValidBits", 1); + + PRINT_SPACE + _OUT << "\"minImageTransferGranularity\": " << std::endl; + { + print_VkExtent3D(obj->minImageTransferGranularity, "minImageTransferGranularity", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDeviceQueueCreateInfo(VkDeviceQueueCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceQueueCreateFlags(obj.flags, "flags", 1); + + print_uint32_t(obj.queueFamilyIndex, "queueFamilyIndex", 1); + + print_uint32_t(obj.queueCount, "queueCount", 1); + + PRINT_SPACE + _OUT << "\"pQueuePriorities\":" << std::endl; + PRINT_SPACE + if (obj.pQueuePriorities) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.queueCount; i++) { + bool isCommaNeeded = (i+1) != obj.queueCount; + print_float(obj.pQueuePriorities[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceQueueCreateFlags(obj->flags, "flags", 1); + + print_uint32_t(obj->queueFamilyIndex, "queueFamilyIndex", 1); + + print_uint32_t(obj->queueCount, "queueCount", 1); + + PRINT_SPACE + _OUT << "\"pQueuePriorities\":" << std::endl; + PRINT_SPACE + if (obj->pQueuePriorities) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->queueCount; i++) { + bool isCommaNeeded = (i+1) != obj->queueCount; + print_float(obj->pQueuePriorities[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDeviceCreateInfo(VkDeviceCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceCreateFlags(obj.flags, "flags", 1); + + print_uint32_t(obj.queueCreateInfoCount, "queueCreateInfoCount", 1); + + PRINT_SPACE + _OUT << "\"pQueueCreateInfos\": " << std::endl; + if (obj.pQueueCreateInfos) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.queueCreateInfoCount; i++) { + if (i+1 == obj.queueCreateInfoCount) + print_VkDeviceQueueCreateInfo(obj.pQueueCreateInfos[i], "pQueueCreateInfos", 0); + else + print_VkDeviceQueueCreateInfo(obj.pQueueCreateInfos[i], "pQueueCreateInfos", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.enabledLayerCount, "enabledLayerCount", 1); + + print_char(obj.ppEnabledLayerNames, "ppEnabledLayerNames", 1); + + print_uint32_t(obj.enabledExtensionCount, "enabledExtensionCount", 1); + + print_char(obj.ppEnabledExtensionNames, "ppEnabledExtensionNames", 1); + + PRINT_SPACE + _OUT << "\"pEnabledFeatures\": " << std::endl; + if (obj.pEnabledFeatures) { + print_VkPhysicalDeviceFeatures(obj.pEnabledFeatures, "pEnabledFeatures", 0); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDeviceCreateInfo(const VkDeviceCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceCreateFlags(obj->flags, "flags", 1); + + print_uint32_t(obj->queueCreateInfoCount, "queueCreateInfoCount", 1); + + PRINT_SPACE + _OUT << "\"pQueueCreateInfos\": " << std::endl; + if (obj->pQueueCreateInfos) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->queueCreateInfoCount; i++) { + if (i+1 == obj->queueCreateInfoCount) + print_VkDeviceQueueCreateInfo(obj->pQueueCreateInfos[i], "pQueueCreateInfos", 0); + else + print_VkDeviceQueueCreateInfo(obj->pQueueCreateInfos[i], "pQueueCreateInfos", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->enabledLayerCount, "enabledLayerCount", 1); + + print_char(obj->ppEnabledLayerNames, "ppEnabledLayerNames", 1); + + print_uint32_t(obj->enabledExtensionCount, "enabledExtensionCount", 1); + + print_char(obj->ppEnabledExtensionNames, "ppEnabledExtensionNames", 1); + + PRINT_SPACE + _OUT << "\"pEnabledFeatures\": " << std::endl; + if (obj->pEnabledFeatures) { + print_VkPhysicalDeviceFeatures(obj->pEnabledFeatures, "pEnabledFeatures", 0); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkExtensionProperties(VkExtensionProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"extensionName\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_EXTENSION_NAME_SIZE; + print_char(obj.extensionName[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_uint32_t(obj.specVersion, "specVersion", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkExtensionProperties(const VkExtensionProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"extensionName\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_EXTENSION_NAME_SIZE; + print_char(obj->extensionName[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_uint32_t(obj->specVersion, "specVersion", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkLayerProperties(VkLayerProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"layerName\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_EXTENSION_NAME_SIZE; + print_char(obj.layerName[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_uint32_t(obj.specVersion, "specVersion", 1); + + print_uint32_t(obj.implementationVersion, "implementationVersion", 1); + + PRINT_SPACE + _OUT << "\"description\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_DESCRIPTION_SIZE; + print_char(obj.description[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkLayerProperties(const VkLayerProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"layerName\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_EXTENSION_NAME_SIZE; + print_char(obj->layerName[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_uint32_t(obj->specVersion, "specVersion", 1); + + print_uint32_t(obj->implementationVersion, "implementationVersion", 1); + + PRINT_SPACE + _OUT << "\"description\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_DESCRIPTION_SIZE; + print_char(obj->description[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSubmitInfo(VkSubmitInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.waitSemaphoreCount, "waitSemaphoreCount", 1); + + PRINT_SPACE + _OUT << "\"pWaitSemaphores\":" << std::endl; + PRINT_SPACE + if (obj.pWaitSemaphores) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.waitSemaphoreCount; i++) { + std:: stringstream tmp; + tmp << "pWaitSemaphores" << "_" << i; + bool isCommaNeeded = (i+1) != obj.waitSemaphoreCount; + print_VkSemaphore(obj.pWaitSemaphores[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + PRINT_SPACE + _OUT << "\"pWaitDstStageMask\":" << std::endl; + PRINT_SPACE + if (obj.pWaitDstStageMask) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.waitSemaphoreCount; i++) { + bool isCommaNeeded = (i+1) != obj.waitSemaphoreCount; + print_VkPipelineStageFlags(obj.pWaitDstStageMask[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj.commandBufferCount, "commandBufferCount", 1); + + PRINT_SPACE + _OUT << "\"pCommandBuffers\":" << std::endl; + PRINT_SPACE + if (obj.pCommandBuffers) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.commandBufferCount; i++) { + std:: stringstream tmp; + tmp << "pCommandBuffers" << "_" << i; + bool isCommaNeeded = (i+1) != obj.commandBufferCount; + print_VkCommandBuffer(obj.pCommandBuffers[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj.signalSemaphoreCount, "signalSemaphoreCount", 1); + + PRINT_SPACE + _OUT << "\"pSignalSemaphores\":" << std::endl; + PRINT_SPACE + if (obj.pSignalSemaphores) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.signalSemaphoreCount; i++) { + std:: stringstream tmp; + tmp << "pSignalSemaphores" << "_" << i; + bool isCommaNeeded = (i+1) != obj.signalSemaphoreCount; + print_VkSemaphore(obj.pSignalSemaphores[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSubmitInfo(const VkSubmitInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->waitSemaphoreCount, "waitSemaphoreCount", 1); + + PRINT_SPACE + _OUT << "\"pWaitSemaphores\":" << std::endl; + PRINT_SPACE + if (obj->pWaitSemaphores) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->waitSemaphoreCount; i++) { + std:: stringstream tmp; + tmp << "pWaitSemaphores" << "_" << i; + bool isCommaNeeded = (i+1) != obj->waitSemaphoreCount; + print_VkSemaphore(obj->pWaitSemaphores[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + PRINT_SPACE + _OUT << "\"pWaitDstStageMask\":" << std::endl; + PRINT_SPACE + if (obj->pWaitDstStageMask) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->waitSemaphoreCount; i++) { + bool isCommaNeeded = (i+1) != obj->waitSemaphoreCount; + print_VkPipelineStageFlags(obj->pWaitDstStageMask[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj->commandBufferCount, "commandBufferCount", 1); + + PRINT_SPACE + _OUT << "\"pCommandBuffers\":" << std::endl; + PRINT_SPACE + if (obj->pCommandBuffers) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->commandBufferCount; i++) { + std:: stringstream tmp; + tmp << "pCommandBuffers" << "_" << i; + bool isCommaNeeded = (i+1) != obj->commandBufferCount; + print_VkCommandBuffer(obj->pCommandBuffers[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj->signalSemaphoreCount, "signalSemaphoreCount", 1); + + PRINT_SPACE + _OUT << "\"pSignalSemaphores\":" << std::endl; + PRINT_SPACE + if (obj->pSignalSemaphores) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->signalSemaphoreCount; i++) { + std:: stringstream tmp; + tmp << "pSignalSemaphores" << "_" << i; + bool isCommaNeeded = (i+1) != obj->signalSemaphoreCount; + print_VkSemaphore(obj->pSignalSemaphores[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkMappedMemoryRange(VkMappedMemoryRange obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "memory" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkDeviceSize(obj.offset, "offset", 1); + + print_VkDeviceSize(obj.size, "size", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkMappedMemoryRange(const VkMappedMemoryRange * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "memory" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkDeviceSize(obj->offset, "offset", 1); + + print_VkDeviceSize(obj->size, "size", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkMemoryAllocateInfo(VkMemoryAllocateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceSize(obj.allocationSize, "allocationSize", 1); + + print_uint32_t(obj.memoryTypeIndex, "memoryTypeIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkMemoryAllocateInfo(const VkMemoryAllocateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceSize(obj->allocationSize, "allocationSize", 1); + + print_uint32_t(obj->memoryTypeIndex, "memoryTypeIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkMemoryRequirements(VkMemoryRequirements obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkDeviceSize(obj.size, "size", 1); + + print_VkDeviceSize(obj.alignment, "alignment", 1); + + print_uint32_t(obj.memoryTypeBits, "memoryTypeBits", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkMemoryRequirements(const VkMemoryRequirements * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkDeviceSize(obj->size, "size", 1); + + print_VkDeviceSize(obj->alignment, "alignment", 1); + + print_uint32_t(obj->memoryTypeBits, "memoryTypeBits", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageSubresource(VkImageSubresource obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkImageAspectFlags(obj.aspectMask, "aspectMask", 1); + + print_uint32_t(obj.mipLevel, "mipLevel", 1); + + print_uint32_t(obj.arrayLayer, "arrayLayer", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageSubresource(const VkImageSubresource * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkImageAspectFlags(obj->aspectMask, "aspectMask", 1); + + print_uint32_t(obj->mipLevel, "mipLevel", 1); + + print_uint32_t(obj->arrayLayer, "arrayLayer", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkFenceCreateInfo(VkFenceCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkFenceCreateFlags(obj.flags, "flags", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkFenceCreateInfo(const VkFenceCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkFenceCreateFlags(obj->flags, "flags", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSemaphoreCreateInfo(VkSemaphoreCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSemaphoreCreateFlags(obj.flags, "flags", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSemaphoreCreateFlags(obj->flags, "flags", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkEventCreateInfo(VkEventCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkEventCreateFlags(obj.flags, "flags", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkEventCreateInfo(const VkEventCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkEventCreateFlags(obj->flags, "flags", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkQueryPoolCreateInfo(VkQueryPoolCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkQueryPoolCreateFlags(obj.flags, "flags", 1); + + print_VkQueryType(obj.queryType, "queryType", 1); + + print_uint32_t(obj.queryCount, "queryCount", 1); + + print_VkQueryPipelineStatisticFlags(obj.pipelineStatistics, "pipelineStatistics", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkQueryPoolCreateFlags(obj->flags, "flags", 1); + + print_VkQueryType(obj->queryType, "queryType", 1); + + print_uint32_t(obj->queryCount, "queryCount", 1); + + print_VkQueryPipelineStatisticFlags(obj->pipelineStatistics, "pipelineStatistics", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkBufferCreateInfo(VkBufferCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBufferCreateFlags(obj.flags, "flags", 1); + + print_VkDeviceSize(obj.size, "size", 1); + + print_VkBufferUsageFlags(obj.usage, "usage", 1); + + print_VkSharingMode(obj.sharingMode, "sharingMode", 1); + + print_uint32_t(obj.queueFamilyIndexCount, "queueFamilyIndexCount", 1); + + PRINT_SPACE + _OUT << "\"pQueueFamilyIndices\":" << std::endl; + PRINT_SPACE + if (obj.pQueueFamilyIndices) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.queueFamilyIndexCount; i++) { + bool isCommaNeeded = (i+1) != obj.queueFamilyIndexCount; + print_uint32_t(obj.pQueueFamilyIndices[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkBufferCreateInfo(const VkBufferCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBufferCreateFlags(obj->flags, "flags", 1); + + print_VkDeviceSize(obj->size, "size", 1); + + print_VkBufferUsageFlags(obj->usage, "usage", 1); + + print_VkSharingMode(obj->sharingMode, "sharingMode", 1); + + print_uint32_t(obj->queueFamilyIndexCount, "queueFamilyIndexCount", 1); + + PRINT_SPACE + _OUT << "\"pQueueFamilyIndices\":" << std::endl; + PRINT_SPACE + if (obj->pQueueFamilyIndices) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->queueFamilyIndexCount; i++) { + bool isCommaNeeded = (i+1) != obj->queueFamilyIndexCount; + print_uint32_t(obj->pQueueFamilyIndices[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkBufferViewCreateInfo(VkBufferViewCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBufferViewCreateFlags(obj.flags, "flags", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkFormat(obj.format, "format", 1); + + print_VkDeviceSize(obj.offset, "offset", 1); + + print_VkDeviceSize(obj.range, "range", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkBufferViewCreateInfo(const VkBufferViewCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBufferViewCreateFlags(obj->flags, "flags", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkFormat(obj->format, "format", 1); + + print_VkDeviceSize(obj->offset, "offset", 1); + + print_VkDeviceSize(obj->range, "range", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageCreateInfo(VkImageCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageCreateFlags(obj.flags, "flags", 1); + + print_VkImageType(obj.imageType, "imageType", 1); + + print_VkFormat(obj.format, "format", 1); + + PRINT_SPACE + _OUT << "\"extent\": " << std::endl; + { + print_VkExtent3D(obj.extent, "extent", 1); + } + + print_uint32_t(obj.mipLevels, "mipLevels", 1); + + print_uint32_t(obj.arrayLayers, "arrayLayers", 1); + + print_VkSampleCountFlagBits(obj.samples, "samples", 1); + + print_VkImageTiling(obj.tiling, "tiling", 1); + + print_VkImageUsageFlags(obj.usage, "usage", 1); + + print_VkSharingMode(obj.sharingMode, "sharingMode", 1); + + print_uint32_t(obj.queueFamilyIndexCount, "queueFamilyIndexCount", 1); + + PRINT_SPACE + _OUT << "\"pQueueFamilyIndices\":" << std::endl; + PRINT_SPACE + if (obj.pQueueFamilyIndices) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.queueFamilyIndexCount; i++) { + bool isCommaNeeded = (i+1) != obj.queueFamilyIndexCount; + print_uint32_t(obj.pQueueFamilyIndices[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_VkImageLayout(obj.initialLayout, "initialLayout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageCreateInfo(const VkImageCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageCreateFlags(obj->flags, "flags", 1); + + print_VkImageType(obj->imageType, "imageType", 1); + + print_VkFormat(obj->format, "format", 1); + + PRINT_SPACE + _OUT << "\"extent\": " << std::endl; + { + print_VkExtent3D(obj->extent, "extent", 1); + } + + print_uint32_t(obj->mipLevels, "mipLevels", 1); + + print_uint32_t(obj->arrayLayers, "arrayLayers", 1); + + print_VkSampleCountFlagBits(obj->samples, "samples", 1); + + print_VkImageTiling(obj->tiling, "tiling", 1); + + print_VkImageUsageFlags(obj->usage, "usage", 1); + + print_VkSharingMode(obj->sharingMode, "sharingMode", 1); + + print_uint32_t(obj->queueFamilyIndexCount, "queueFamilyIndexCount", 1); + + PRINT_SPACE + _OUT << "\"pQueueFamilyIndices\":" << std::endl; + PRINT_SPACE + if (obj->pQueueFamilyIndices) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->queueFamilyIndexCount; i++) { + bool isCommaNeeded = (i+1) != obj->queueFamilyIndexCount; + print_uint32_t(obj->pQueueFamilyIndices[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_VkImageLayout(obj->initialLayout, "initialLayout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSubresourceLayout(VkSubresourceLayout obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkDeviceSize(obj.offset, "offset", 1); + + print_VkDeviceSize(obj.size, "size", 1); + + print_VkDeviceSize(obj.rowPitch, "rowPitch", 1); + + print_VkDeviceSize(obj.arrayPitch, "arrayPitch", 1); + + print_VkDeviceSize(obj.depthPitch, "depthPitch", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSubresourceLayout(const VkSubresourceLayout * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkDeviceSize(obj->offset, "offset", 1); + + print_VkDeviceSize(obj->size, "size", 1); + + print_VkDeviceSize(obj->rowPitch, "rowPitch", 1); + + print_VkDeviceSize(obj->arrayPitch, "arrayPitch", 1); + + print_VkDeviceSize(obj->depthPitch, "depthPitch", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkComponentMapping(VkComponentMapping obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkComponentSwizzle(obj.r, "r", 1); + + print_VkComponentSwizzle(obj.g, "g", 1); + + print_VkComponentSwizzle(obj.b, "b", 1); + + print_VkComponentSwizzle(obj.a, "a", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkComponentMapping(const VkComponentMapping * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkComponentSwizzle(obj->r, "r", 1); + + print_VkComponentSwizzle(obj->g, "g", 1); + + print_VkComponentSwizzle(obj->b, "b", 1); + + print_VkComponentSwizzle(obj->a, "a", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageViewCreateInfo(VkImageViewCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageViewCreateFlags(obj.flags, "flags", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkImageViewType(obj.viewType, "viewType", 1); + + print_VkFormat(obj.format, "format", 1); + + PRINT_SPACE + _OUT << "\"components\": " << std::endl; + { + print_VkComponentMapping(obj.components, "components", 1); + } + + PRINT_SPACE + _OUT << "\"subresourceRange\": " << std::endl; + { + print_VkImageSubresourceRange(obj.subresourceRange, "subresourceRange", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageViewCreateInfo(const VkImageViewCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageViewCreateFlags(obj->flags, "flags", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkImageViewType(obj->viewType, "viewType", 1); + + print_VkFormat(obj->format, "format", 1); + + PRINT_SPACE + _OUT << "\"components\": " << std::endl; + { + print_VkComponentMapping(obj->components, "components", 1); + } + + PRINT_SPACE + _OUT << "\"subresourceRange\": " << std::endl; + { + print_VkImageSubresourceRange(obj->subresourceRange, "subresourceRange", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineCacheCreateInfo(VkPipelineCacheCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineCacheCreateFlags(obj.flags, "flags", 1); + + print_size_t(obj.initialDataSize, "initialDataSize", 1); + + /** Note: Ignoring void* data. **/ + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineCacheCreateFlags(obj->flags, "flags", 1); + + print_size_t(obj->initialDataSize, "initialDataSize", 1); + + /** Note: Ignoring void* data. **/ + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSpecializationMapEntry(VkSpecializationMapEntry obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj.constantID, "constantID", 1); + + print_uint32_t(obj.offset, "offset", 1); + + print_size_t(obj.size, "size", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSpecializationMapEntry(const VkSpecializationMapEntry * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj->constantID, "constantID", 1); + + print_uint32_t(obj->offset, "offset", 1); + + print_size_t(obj->size, "size", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSpecializationInfo(VkSpecializationInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj.mapEntryCount, "mapEntryCount", 1); + + PRINT_SPACE + _OUT << "\"pMapEntries\": " << std::endl; + if (obj.pMapEntries) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.mapEntryCount; i++) { + if (i+1 == obj.mapEntryCount) + print_VkSpecializationMapEntry(obj.pMapEntries[i], "pMapEntries", 0); + else + print_VkSpecializationMapEntry(obj.pMapEntries[i], "pMapEntries", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_size_t(obj.dataSize, "dataSize", 1); + + print_void_data(obj.pData, int(obj.dataSize), "pData", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSpecializationInfo(const VkSpecializationInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj->mapEntryCount, "mapEntryCount", 1); + + PRINT_SPACE + _OUT << "\"pMapEntries\": " << std::endl; + if (obj->pMapEntries) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->mapEntryCount; i++) { + if (i+1 == obj->mapEntryCount) + print_VkSpecializationMapEntry(obj->pMapEntries[i], "pMapEntries", 0); + else + print_VkSpecializationMapEntry(obj->pMapEntries[i], "pMapEntries", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_size_t(obj->dataSize, "dataSize", 1); + + print_void_data(obj->pData, int(obj->dataSize), "pData", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineShaderStageCreateInfo(VkPipelineShaderStageCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineShaderStageCreateFlags(obj.flags, "flags", 1); + + print_VkShaderStageFlagBits(obj.stage, "stage", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "module" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_char(obj.pName, "pName", 1); + + PRINT_SPACE + _OUT << "\"pSpecializationInfo\": " << std::endl; + if (obj.pSpecializationInfo) { + print_VkSpecializationInfo(obj.pSpecializationInfo, "pSpecializationInfo", 0); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineShaderStageCreateFlags(obj->flags, "flags", 1); + + print_VkShaderStageFlagBits(obj->stage, "stage", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "module" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_char(obj->pName, "pName", 1); + + PRINT_SPACE + _OUT << "\"pSpecializationInfo\": " << std::endl; + if (obj->pSpecializationInfo) { + print_VkSpecializationInfo(obj->pSpecializationInfo, "pSpecializationInfo", 0); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkComputePipelineCreateInfo(VkComputePipelineCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineCreateFlags(obj.flags, "flags", 1); + + PRINT_SPACE + _OUT << "\"stage\": " << std::endl; + { + print_VkPipelineShaderStageCreateInfo(obj.stage, "stage", 1); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "layout" << "\"" << " : " << "\"" << "\"," << std::endl; + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "basePipelineHandle" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_int32_t(obj.basePipelineIndex, "basePipelineIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineCreateFlags(obj->flags, "flags", 1); + + PRINT_SPACE + _OUT << "\"stage\": " << std::endl; + { + print_VkPipelineShaderStageCreateInfo(obj->stage, "stage", 1); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "layout" << "\"" << " : " << "\"" << "\"," << std::endl; + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "basePipelineHandle" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_int32_t(obj->basePipelineIndex, "basePipelineIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkVertexInputBindingDescription(VkVertexInputBindingDescription obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj.binding, "binding", 1); + + print_uint32_t(obj.stride, "stride", 1); + + print_VkVertexInputRate(obj.inputRate, "inputRate", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkVertexInputBindingDescription(const VkVertexInputBindingDescription * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj->binding, "binding", 1); + + print_uint32_t(obj->stride, "stride", 1); + + print_VkVertexInputRate(obj->inputRate, "inputRate", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkVertexInputAttributeDescription(VkVertexInputAttributeDescription obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj.location, "location", 1); + + print_uint32_t(obj.binding, "binding", 1); + + print_VkFormat(obj.format, "format", 1); + + print_uint32_t(obj.offset, "offset", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkVertexInputAttributeDescription(const VkVertexInputAttributeDescription * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj->location, "location", 1); + + print_uint32_t(obj->binding, "binding", 1); + + print_VkFormat(obj->format, "format", 1); + + print_uint32_t(obj->offset, "offset", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineVertexInputStateCreateInfo(VkPipelineVertexInputStateCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineVertexInputStateCreateFlags(obj.flags, "flags", 1); + + print_uint32_t(obj.vertexBindingDescriptionCount, "vertexBindingDescriptionCount", 1); + + PRINT_SPACE + _OUT << "\"pVertexBindingDescriptions\": " << std::endl; + if (obj.pVertexBindingDescriptions) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.vertexBindingDescriptionCount; i++) { + if (i+1 == obj.vertexBindingDescriptionCount) + print_VkVertexInputBindingDescription(obj.pVertexBindingDescriptions[i], "pVertexBindingDescriptions", 0); + else + print_VkVertexInputBindingDescription(obj.pVertexBindingDescriptions[i], "pVertexBindingDescriptions", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.vertexAttributeDescriptionCount, "vertexAttributeDescriptionCount", 1); + + PRINT_SPACE + _OUT << "\"pVertexAttributeDescriptions\": " << std::endl; + if (obj.pVertexAttributeDescriptions) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.vertexAttributeDescriptionCount; i++) { + if (i+1 == obj.vertexAttributeDescriptionCount) + print_VkVertexInputAttributeDescription(obj.pVertexAttributeDescriptions[i], "pVertexAttributeDescriptions", 0); + else + print_VkVertexInputAttributeDescription(obj.pVertexAttributeDescriptions[i], "pVertexAttributeDescriptions", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineVertexInputStateCreateFlags(obj->flags, "flags", 1); + + print_uint32_t(obj->vertexBindingDescriptionCount, "vertexBindingDescriptionCount", 1); + + PRINT_SPACE + _OUT << "\"pVertexBindingDescriptions\": " << std::endl; + if (obj->pVertexBindingDescriptions) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->vertexBindingDescriptionCount; i++) { + if (i+1 == obj->vertexBindingDescriptionCount) + print_VkVertexInputBindingDescription(obj->pVertexBindingDescriptions[i], "pVertexBindingDescriptions", 0); + else + print_VkVertexInputBindingDescription(obj->pVertexBindingDescriptions[i], "pVertexBindingDescriptions", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->vertexAttributeDescriptionCount, "vertexAttributeDescriptionCount", 1); + + PRINT_SPACE + _OUT << "\"pVertexAttributeDescriptions\": " << std::endl; + if (obj->pVertexAttributeDescriptions) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->vertexAttributeDescriptionCount; i++) { + if (i+1 == obj->vertexAttributeDescriptionCount) + print_VkVertexInputAttributeDescription(obj->pVertexAttributeDescriptions[i], "pVertexAttributeDescriptions", 0); + else + print_VkVertexInputAttributeDescription(obj->pVertexAttributeDescriptions[i], "pVertexAttributeDescriptions", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineInputAssemblyStateCreateInfo(VkPipelineInputAssemblyStateCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineInputAssemblyStateCreateFlags(obj.flags, "flags", 1); + + print_VkPrimitiveTopology(obj.topology, "topology", 1); + + print_VkBool32(obj.primitiveRestartEnable, "primitiveRestartEnable", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineInputAssemblyStateCreateFlags(obj->flags, "flags", 1); + + print_VkPrimitiveTopology(obj->topology, "topology", 1); + + print_VkBool32(obj->primitiveRestartEnable, "primitiveRestartEnable", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineTessellationStateCreateInfo(VkPipelineTessellationStateCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineTessellationStateCreateFlags(obj.flags, "flags", 1); + + print_uint32_t(obj.patchControlPoints, "patchControlPoints", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineTessellationStateCreateFlags(obj->flags, "flags", 1); + + print_uint32_t(obj->patchControlPoints, "patchControlPoints", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkViewport(VkViewport obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_float(obj.x, "x", 1); + + print_float(obj.y, "y", 1); + + print_float(obj.width, "width", 1); + + print_float(obj.height, "height", 1); + + print_float(obj.minDepth, "minDepth", 1); + + print_float(obj.maxDepth, "maxDepth", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkViewport(const VkViewport * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_float(obj->x, "x", 1); + + print_float(obj->y, "y", 1); + + print_float(obj->width, "width", 1); + + print_float(obj->height, "height", 1); + + print_float(obj->minDepth, "minDepth", 1); + + print_float(obj->maxDepth, "maxDepth", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineViewportStateCreateInfo(VkPipelineViewportStateCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineViewportStateCreateFlags(obj.flags, "flags", 1); + + print_uint32_t(obj.viewportCount, "viewportCount", 1); + + PRINT_SPACE + _OUT << "\"pViewports\": " << std::endl; + if (obj.pViewports) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.viewportCount; i++) { + if (i+1 == obj.viewportCount) + print_VkViewport(obj.pViewports[i], "pViewports", 0); + else + print_VkViewport(obj.pViewports[i], "pViewports", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.scissorCount, "scissorCount", 1); + + PRINT_SPACE + _OUT << "\"pScissors\": " << std::endl; + if (obj.pScissors) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.scissorCount; i++) { + if (i+1 == obj.scissorCount) + print_VkRect2D(obj.pScissors[i], "pScissors", 0); + else + print_VkRect2D(obj.pScissors[i], "pScissors", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineViewportStateCreateFlags(obj->flags, "flags", 1); + + print_uint32_t(obj->viewportCount, "viewportCount", 1); + + PRINT_SPACE + _OUT << "\"pViewports\": " << std::endl; + if (obj->pViewports) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->viewportCount; i++) { + if (i+1 == obj->viewportCount) + print_VkViewport(obj->pViewports[i], "pViewports", 0); + else + print_VkViewport(obj->pViewports[i], "pViewports", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->scissorCount, "scissorCount", 1); + + PRINT_SPACE + _OUT << "\"pScissors\": " << std::endl; + if (obj->pScissors) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->scissorCount; i++) { + if (i+1 == obj->scissorCount) + print_VkRect2D(obj->pScissors[i], "pScissors", 0); + else + print_VkRect2D(obj->pScissors[i], "pScissors", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineRasterizationStateCreateInfo(VkPipelineRasterizationStateCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineRasterizationStateCreateFlags(obj.flags, "flags", 1); + + print_VkBool32(obj.depthClampEnable, "depthClampEnable", 1); + + print_VkBool32(obj.rasterizerDiscardEnable, "rasterizerDiscardEnable", 1); + + print_VkPolygonMode(obj.polygonMode, "polygonMode", 1); + + print_VkCullModeFlags(obj.cullMode, "cullMode", 1); + + print_VkFrontFace(obj.frontFace, "frontFace", 1); + + print_VkBool32(obj.depthBiasEnable, "depthBiasEnable", 1); + + print_float(obj.depthBiasConstantFactor, "depthBiasConstantFactor", 1); + + print_float(obj.depthBiasClamp, "depthBiasClamp", 1); + + print_float(obj.depthBiasSlopeFactor, "depthBiasSlopeFactor", 1); + + print_float(obj.lineWidth, "lineWidth", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineRasterizationStateCreateFlags(obj->flags, "flags", 1); + + print_VkBool32(obj->depthClampEnable, "depthClampEnable", 1); + + print_VkBool32(obj->rasterizerDiscardEnable, "rasterizerDiscardEnable", 1); + + print_VkPolygonMode(obj->polygonMode, "polygonMode", 1); + + print_VkCullModeFlags(obj->cullMode, "cullMode", 1); + + print_VkFrontFace(obj->frontFace, "frontFace", 1); + + print_VkBool32(obj->depthBiasEnable, "depthBiasEnable", 1); + + print_float(obj->depthBiasConstantFactor, "depthBiasConstantFactor", 1); + + print_float(obj->depthBiasClamp, "depthBiasClamp", 1); + + print_float(obj->depthBiasSlopeFactor, "depthBiasSlopeFactor", 1); + + print_float(obj->lineWidth, "lineWidth", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineMultisampleStateCreateInfo(VkPipelineMultisampleStateCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineMultisampleStateCreateFlags(obj.flags, "flags", 1); + + print_VkSampleCountFlagBits(obj.rasterizationSamples, "rasterizationSamples", 1); + + print_VkBool32(obj.sampleShadingEnable, "sampleShadingEnable", 1); + + print_float(obj.minSampleShading, "minSampleShading", 1); + + uint32_t sampleMaskSize = ((obj.rasterizationSamples + 31) / 32); + PRINT_SPACE + _OUT << "\"pSampleMask\":" << std::endl; + PRINT_SPACE + if (obj.pSampleMask) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < sampleMaskSize; i++) { + bool isCommaNeeded = (i+1) != sampleMaskSize; + print_uint32_t(obj.pSampleMask[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_VkBool32(obj.alphaToCoverageEnable, "alphaToCoverageEnable", 1); + + print_VkBool32(obj.alphaToOneEnable, "alphaToOneEnable", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineMultisampleStateCreateFlags(obj->flags, "flags", 1); + + print_VkSampleCountFlagBits(obj->rasterizationSamples, "rasterizationSamples", 1); + + print_VkBool32(obj->sampleShadingEnable, "sampleShadingEnable", 1); + + print_float(obj->minSampleShading, "minSampleShading", 1); + + uint32_t sampleMaskSize = ((obj->rasterizationSamples + 31) / 32); + PRINT_SPACE + _OUT << "\"pSampleMask\":" << std::endl; + PRINT_SPACE + if (obj->pSampleMask) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < sampleMaskSize; i++) { + bool isCommaNeeded = (i+1) != sampleMaskSize; + print_uint32_t(obj->pSampleMask[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_VkBool32(obj->alphaToCoverageEnable, "alphaToCoverageEnable", 1); + + print_VkBool32(obj->alphaToOneEnable, "alphaToOneEnable", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkStencilOpState(VkStencilOpState obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStencilOp(obj.failOp, "failOp", 1); + + print_VkStencilOp(obj.passOp, "passOp", 1); + + print_VkStencilOp(obj.depthFailOp, "depthFailOp", 1); + + print_VkCompareOp(obj.compareOp, "compareOp", 1); + + print_uint32_t(obj.compareMask, "compareMask", 1); + + print_uint32_t(obj.writeMask, "writeMask", 1); + + print_uint32_t(obj.reference, "reference", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkStencilOpState(const VkStencilOpState * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStencilOp(obj->failOp, "failOp", 1); + + print_VkStencilOp(obj->passOp, "passOp", 1); + + print_VkStencilOp(obj->depthFailOp, "depthFailOp", 1); + + print_VkCompareOp(obj->compareOp, "compareOp", 1); + + print_uint32_t(obj->compareMask, "compareMask", 1); + + print_uint32_t(obj->writeMask, "writeMask", 1); + + print_uint32_t(obj->reference, "reference", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineDepthStencilStateCreateInfo(VkPipelineDepthStencilStateCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineDepthStencilStateCreateFlags(obj.flags, "flags", 1); + + print_VkBool32(obj.depthTestEnable, "depthTestEnable", 1); + + print_VkBool32(obj.depthWriteEnable, "depthWriteEnable", 1); + + print_VkCompareOp(obj.depthCompareOp, "depthCompareOp", 1); + + print_VkBool32(obj.depthBoundsTestEnable, "depthBoundsTestEnable", 1); + + print_VkBool32(obj.stencilTestEnable, "stencilTestEnable", 1); + + PRINT_SPACE + _OUT << "\"front\": " << std::endl; + { + print_VkStencilOpState(obj.front, "front", 1); + } + + PRINT_SPACE + _OUT << "\"back\": " << std::endl; + { + print_VkStencilOpState(obj.back, "back", 1); + } + + print_float(obj.minDepthBounds, "minDepthBounds", 1); + + print_float(obj.maxDepthBounds, "maxDepthBounds", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineDepthStencilStateCreateFlags(obj->flags, "flags", 1); + + print_VkBool32(obj->depthTestEnable, "depthTestEnable", 1); + + print_VkBool32(obj->depthWriteEnable, "depthWriteEnable", 1); + + print_VkCompareOp(obj->depthCompareOp, "depthCompareOp", 1); + + print_VkBool32(obj->depthBoundsTestEnable, "depthBoundsTestEnable", 1); + + print_VkBool32(obj->stencilTestEnable, "stencilTestEnable", 1); + + PRINT_SPACE + _OUT << "\"front\": " << std::endl; + { + print_VkStencilOpState(obj->front, "front", 1); + } + + PRINT_SPACE + _OUT << "\"back\": " << std::endl; + { + print_VkStencilOpState(obj->back, "back", 1); + } + + print_float(obj->minDepthBounds, "minDepthBounds", 1); + + print_float(obj->maxDepthBounds, "maxDepthBounds", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineColorBlendAttachmentState(VkPipelineColorBlendAttachmentState obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkBool32(obj.blendEnable, "blendEnable", 1); + + print_VkBlendFactor(obj.srcColorBlendFactor, "srcColorBlendFactor", 1); + + print_VkBlendFactor(obj.dstColorBlendFactor, "dstColorBlendFactor", 1); + + print_VkBlendOp(obj.colorBlendOp, "colorBlendOp", 1); + + print_VkBlendFactor(obj.srcAlphaBlendFactor, "srcAlphaBlendFactor", 1); + + print_VkBlendFactor(obj.dstAlphaBlendFactor, "dstAlphaBlendFactor", 1); + + print_VkBlendOp(obj.alphaBlendOp, "alphaBlendOp", 1); + + print_VkColorComponentFlags(obj.colorWriteMask, "colorWriteMask", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineColorBlendAttachmentState(const VkPipelineColorBlendAttachmentState * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkBool32(obj->blendEnable, "blendEnable", 1); + + print_VkBlendFactor(obj->srcColorBlendFactor, "srcColorBlendFactor", 1); + + print_VkBlendFactor(obj->dstColorBlendFactor, "dstColorBlendFactor", 1); + + print_VkBlendOp(obj->colorBlendOp, "colorBlendOp", 1); + + print_VkBlendFactor(obj->srcAlphaBlendFactor, "srcAlphaBlendFactor", 1); + + print_VkBlendFactor(obj->dstAlphaBlendFactor, "dstAlphaBlendFactor", 1); + + print_VkBlendOp(obj->alphaBlendOp, "alphaBlendOp", 1); + + print_VkColorComponentFlags(obj->colorWriteMask, "colorWriteMask", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineColorBlendStateCreateInfo(VkPipelineColorBlendStateCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineColorBlendStateCreateFlags(obj.flags, "flags", 1); + + print_VkBool32(obj.logicOpEnable, "logicOpEnable", 1); + + print_VkLogicOp(obj.logicOp, "logicOp", 1); + + print_uint32_t(obj.attachmentCount, "attachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pAttachments\": " << std::endl; + if (obj.pAttachments) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.attachmentCount; i++) { + if (i+1 == obj.attachmentCount) + print_VkPipelineColorBlendAttachmentState(obj.pAttachments[i], "pAttachments", 0); + else + print_VkPipelineColorBlendAttachmentState(obj.pAttachments[i], "pAttachments", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"blendConstants\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 4; i++) { + bool isCommaNeeded = (i+1) != 4; + print_float(obj.blendConstants[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineColorBlendStateCreateFlags(obj->flags, "flags", 1); + + print_VkBool32(obj->logicOpEnable, "logicOpEnable", 1); + + print_VkLogicOp(obj->logicOp, "logicOp", 1); + + print_uint32_t(obj->attachmentCount, "attachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pAttachments\": " << std::endl; + if (obj->pAttachments) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->attachmentCount; i++) { + if (i+1 == obj->attachmentCount) + print_VkPipelineColorBlendAttachmentState(obj->pAttachments[i], "pAttachments", 0); + else + print_VkPipelineColorBlendAttachmentState(obj->pAttachments[i], "pAttachments", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"blendConstants\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 4; i++) { + bool isCommaNeeded = (i+1) != 4; + print_float(obj->blendConstants[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineDynamicStateCreateInfo(VkPipelineDynamicStateCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineDynamicStateCreateFlags(obj.flags, "flags", 1); + + print_uint32_t(obj.dynamicStateCount, "dynamicStateCount", 1); + + PRINT_SPACE + _OUT << "\"pDynamicStates\":" << std::endl; + PRINT_SPACE + if (obj.pDynamicStates) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.dynamicStateCount; i++) { + bool isCommaNeeded = (i+1) != obj.dynamicStateCount; + print_VkDynamicState(obj.pDynamicStates[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineDynamicStateCreateFlags(obj->flags, "flags", 1); + + print_uint32_t(obj->dynamicStateCount, "dynamicStateCount", 1); + + PRINT_SPACE + _OUT << "\"pDynamicStates\":" << std::endl; + PRINT_SPACE + if (obj->pDynamicStates) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->dynamicStateCount; i++) { + bool isCommaNeeded = (i+1) != obj->dynamicStateCount; + print_VkDynamicState(obj->pDynamicStates[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkGraphicsPipelineCreateInfo(VkGraphicsPipelineCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineCreateFlags(obj.flags, "flags", 1); + + print_uint32_t(obj.stageCount, "stageCount", 1); + + PRINT_SPACE + _OUT << "\"pStages\": " << std::endl; + if (obj.pStages) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.stageCount; i++) { + if (i+1 == obj.stageCount) + print_VkPipelineShaderStageCreateInfo(obj.pStages[i], "pStages", 0); + else + print_VkPipelineShaderStageCreateInfo(obj.pStages[i], "pStages", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pVertexInputState\": " << std::endl; + if (obj.pVertexInputState) { + print_VkPipelineVertexInputStateCreateInfo(obj.pVertexInputState, "pVertexInputState", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pInputAssemblyState\": " << std::endl; + if (obj.pInputAssemblyState) { + print_VkPipelineInputAssemblyStateCreateInfo(obj.pInputAssemblyState, "pInputAssemblyState", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pTessellationState\": " << std::endl; + if (obj.pTessellationState) { + print_VkPipelineTessellationStateCreateInfo(obj.pTessellationState, "pTessellationState", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pViewportState\": " << std::endl; + if (obj.pViewportState) { + print_VkPipelineViewportStateCreateInfo(obj.pViewportState, "pViewportState", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pRasterizationState\": " << std::endl; + if (obj.pRasterizationState) { + print_VkPipelineRasterizationStateCreateInfo(obj.pRasterizationState, "pRasterizationState", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pMultisampleState\": " << std::endl; + if (obj.pMultisampleState) { + print_VkPipelineMultisampleStateCreateInfo(obj.pMultisampleState, "pMultisampleState", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pDepthStencilState\": " << std::endl; + if (obj.pDepthStencilState) { + print_VkPipelineDepthStencilStateCreateInfo(obj.pDepthStencilState, "pDepthStencilState", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pColorBlendState\": " << std::endl; + if (obj.pColorBlendState) { + print_VkPipelineColorBlendStateCreateInfo(obj.pColorBlendState, "pColorBlendState", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pDynamicState\": " << std::endl; + if (obj.pDynamicState) { + print_VkPipelineDynamicStateCreateInfo(obj.pDynamicState, "pDynamicState", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "layout" << "\"" << " : " << "\"" << "\"," << std::endl; + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "renderPass" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj.subpass, "subpass", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "basePipelineHandle" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_int32_t(obj.basePipelineIndex, "basePipelineIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineCreateFlags(obj->flags, "flags", 1); + + print_uint32_t(obj->stageCount, "stageCount", 1); + + PRINT_SPACE + _OUT << "\"pStages\": " << std::endl; + if (obj->pStages) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->stageCount; i++) { + if (i+1 == obj->stageCount) + print_VkPipelineShaderStageCreateInfo(obj->pStages[i], "pStages", 0); + else + print_VkPipelineShaderStageCreateInfo(obj->pStages[i], "pStages", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pVertexInputState\": " << std::endl; + if (obj->pVertexInputState) { + print_VkPipelineVertexInputStateCreateInfo(obj->pVertexInputState, "pVertexInputState", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pInputAssemblyState\": " << std::endl; + if (obj->pInputAssemblyState) { + print_VkPipelineInputAssemblyStateCreateInfo(obj->pInputAssemblyState, "pInputAssemblyState", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pTessellationState\": " << std::endl; + if (obj->pTessellationState) { + print_VkPipelineTessellationStateCreateInfo(obj->pTessellationState, "pTessellationState", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pViewportState\": " << std::endl; + if (obj->pViewportState) { + print_VkPipelineViewportStateCreateInfo(obj->pViewportState, "pViewportState", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pRasterizationState\": " << std::endl; + if (obj->pRasterizationState) { + print_VkPipelineRasterizationStateCreateInfo(obj->pRasterizationState, "pRasterizationState", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pMultisampleState\": " << std::endl; + if (obj->pMultisampleState) { + print_VkPipelineMultisampleStateCreateInfo(obj->pMultisampleState, "pMultisampleState", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pDepthStencilState\": " << std::endl; + if (obj->pDepthStencilState) { + print_VkPipelineDepthStencilStateCreateInfo(obj->pDepthStencilState, "pDepthStencilState", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pColorBlendState\": " << std::endl; + if (obj->pColorBlendState) { + print_VkPipelineColorBlendStateCreateInfo(obj->pColorBlendState, "pColorBlendState", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pDynamicState\": " << std::endl; + if (obj->pDynamicState) { + print_VkPipelineDynamicStateCreateInfo(obj->pDynamicState, "pDynamicState", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "layout" << "\"" << " : " << "\"" << "\"," << std::endl; + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "renderPass" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj->subpass, "subpass", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "basePipelineHandle" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_int32_t(obj->basePipelineIndex, "basePipelineIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPushConstantRange(VkPushConstantRange obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkShaderStageFlags(obj.stageFlags, "stageFlags", 1); + + print_uint32_t(obj.offset, "offset", 1); + + print_uint32_t(obj.size, "size", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPushConstantRange(const VkPushConstantRange * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkShaderStageFlags(obj->stageFlags, "stageFlags", 1); + + print_uint32_t(obj->offset, "offset", 1); + + print_uint32_t(obj->size, "size", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineLayoutCreateInfo(VkPipelineLayoutCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineLayoutCreateFlags(obj.flags, "flags", 1); + + print_uint32_t(obj.setLayoutCount, "setLayoutCount", 1); + + PRINT_SPACE + _OUT << "\"pSetLayouts\":" << std::endl; + PRINT_SPACE + if (obj.pSetLayouts) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.setLayoutCount; i++) { + std:: stringstream tmp; + tmp << "pSetLayouts" << "_" << i; + bool isCommaNeeded = (i+1) != obj.setLayoutCount; + print_VkDescriptorSetLayout(obj.pSetLayouts[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj.pushConstantRangeCount, "pushConstantRangeCount", 1); + + PRINT_SPACE + _OUT << "\"pPushConstantRanges\": " << std::endl; + if (obj.pPushConstantRanges) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.pushConstantRangeCount; i++) { + if (i+1 == obj.pushConstantRangeCount) + print_VkPushConstantRange(obj.pPushConstantRanges[i], "pPushConstantRanges", 0); + else + print_VkPushConstantRange(obj.pPushConstantRanges[i], "pPushConstantRanges", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineLayoutCreateFlags(obj->flags, "flags", 1); + + print_uint32_t(obj->setLayoutCount, "setLayoutCount", 1); + + PRINT_SPACE + _OUT << "\"pSetLayouts\":" << std::endl; + PRINT_SPACE + if (obj->pSetLayouts) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->setLayoutCount; i++) { + std:: stringstream tmp; + tmp << "pSetLayouts" << "_" << i; + bool isCommaNeeded = (i+1) != obj->setLayoutCount; + print_VkDescriptorSetLayout(obj->pSetLayouts[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj->pushConstantRangeCount, "pushConstantRangeCount", 1); + + PRINT_SPACE + _OUT << "\"pPushConstantRanges\": " << std::endl; + if (obj->pPushConstantRanges) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->pushConstantRangeCount; i++) { + if (i+1 == obj->pushConstantRangeCount) + print_VkPushConstantRange(obj->pPushConstantRanges[i], "pPushConstantRanges", 0); + else + print_VkPushConstantRange(obj->pPushConstantRanges[i], "pPushConstantRanges", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSamplerCreateInfo(VkSamplerCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSamplerCreateFlags(obj.flags, "flags", 1); + + print_VkFilter(obj.magFilter, "magFilter", 1); + + print_VkFilter(obj.minFilter, "minFilter", 1); + + print_VkSamplerMipmapMode(obj.mipmapMode, "mipmapMode", 1); + + print_VkSamplerAddressMode(obj.addressModeU, "addressModeU", 1); + + print_VkSamplerAddressMode(obj.addressModeV, "addressModeV", 1); + + print_VkSamplerAddressMode(obj.addressModeW, "addressModeW", 1); + + print_float(obj.mipLodBias, "mipLodBias", 1); + + print_VkBool32(obj.anisotropyEnable, "anisotropyEnable", 1); + + print_float(obj.maxAnisotropy, "maxAnisotropy", 1); + + print_VkBool32(obj.compareEnable, "compareEnable", 1); + + print_VkCompareOp(obj.compareOp, "compareOp", 1); + + print_float(obj.minLod, "minLod", 1); + + print_float(obj.maxLod, "maxLod", 1); + + print_VkBorderColor(obj.borderColor, "borderColor", 1); + + print_VkBool32(obj.unnormalizedCoordinates, "unnormalizedCoordinates", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSamplerCreateInfo(const VkSamplerCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSamplerCreateFlags(obj->flags, "flags", 1); + + print_VkFilter(obj->magFilter, "magFilter", 1); + + print_VkFilter(obj->minFilter, "minFilter", 1); + + print_VkSamplerMipmapMode(obj->mipmapMode, "mipmapMode", 1); + + print_VkSamplerAddressMode(obj->addressModeU, "addressModeU", 1); + + print_VkSamplerAddressMode(obj->addressModeV, "addressModeV", 1); + + print_VkSamplerAddressMode(obj->addressModeW, "addressModeW", 1); + + print_float(obj->mipLodBias, "mipLodBias", 1); + + print_VkBool32(obj->anisotropyEnable, "anisotropyEnable", 1); + + print_float(obj->maxAnisotropy, "maxAnisotropy", 1); + + print_VkBool32(obj->compareEnable, "compareEnable", 1); + + print_VkCompareOp(obj->compareOp, "compareOp", 1); + + print_float(obj->minLod, "minLod", 1); + + print_float(obj->maxLod, "maxLod", 1); + + print_VkBorderColor(obj->borderColor, "borderColor", 1); + + print_VkBool32(obj->unnormalizedCoordinates, "unnormalizedCoordinates", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkCopyDescriptorSet(VkCopyDescriptorSet obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "srcSet" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj.srcBinding, "srcBinding", 1); + + print_uint32_t(obj.srcArrayElement, "srcArrayElement", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "dstSet" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj.dstBinding, "dstBinding", 1); + + print_uint32_t(obj.dstArrayElement, "dstArrayElement", 1); + + print_uint32_t(obj.descriptorCount, "descriptorCount", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkCopyDescriptorSet(const VkCopyDescriptorSet * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "srcSet" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj->srcBinding, "srcBinding", 1); + + print_uint32_t(obj->srcArrayElement, "srcArrayElement", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "dstSet" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj->dstBinding, "dstBinding", 1); + + print_uint32_t(obj->dstArrayElement, "dstArrayElement", 1); + + print_uint32_t(obj->descriptorCount, "descriptorCount", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDescriptorBufferInfo(VkDescriptorBufferInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkDeviceSize(obj.offset, "offset", 1); + + print_VkDeviceSize(obj.range, "range", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDescriptorBufferInfo(const VkDescriptorBufferInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkDeviceSize(obj->offset, "offset", 1); + + print_VkDeviceSize(obj->range, "range", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDescriptorImageInfo(VkDescriptorImageInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "sampler" << "\"" << " : " << "\"" << "\"," << std::endl; + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "imageView" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkImageLayout(obj.imageLayout, "imageLayout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDescriptorImageInfo(const VkDescriptorImageInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "sampler" << "\"" << " : " << "\"" << "\"," << std::endl; + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "imageView" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkImageLayout(obj->imageLayout, "imageLayout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDescriptorPoolSize(VkDescriptorPoolSize obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkDescriptorType(obj.type, "type", 1); + + print_uint32_t(obj.descriptorCount, "descriptorCount", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDescriptorPoolSize(const VkDescriptorPoolSize * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkDescriptorType(obj->type, "type", 1); + + print_uint32_t(obj->descriptorCount, "descriptorCount", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDescriptorPoolCreateInfo(VkDescriptorPoolCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDescriptorPoolCreateFlags(obj.flags, "flags", 1); + + print_uint32_t(obj.maxSets, "maxSets", 1); + + print_uint32_t(obj.poolSizeCount, "poolSizeCount", 1); + + PRINT_SPACE + _OUT << "\"pPoolSizes\": " << std::endl; + if (obj.pPoolSizes) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.poolSizeCount; i++) { + if (i+1 == obj.poolSizeCount) + print_VkDescriptorPoolSize(obj.pPoolSizes[i], "pPoolSizes", 0); + else + print_VkDescriptorPoolSize(obj.pPoolSizes[i], "pPoolSizes", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDescriptorPoolCreateFlags(obj->flags, "flags", 1); + + print_uint32_t(obj->maxSets, "maxSets", 1); + + print_uint32_t(obj->poolSizeCount, "poolSizeCount", 1); + + PRINT_SPACE + _OUT << "\"pPoolSizes\": " << std::endl; + if (obj->pPoolSizes) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->poolSizeCount; i++) { + if (i+1 == obj->poolSizeCount) + print_VkDescriptorPoolSize(obj->pPoolSizes[i], "pPoolSizes", 0); + else + print_VkDescriptorPoolSize(obj->pPoolSizes[i], "pPoolSizes", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDescriptorSetAllocateInfo(VkDescriptorSetAllocateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "descriptorPool" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj.descriptorSetCount, "descriptorSetCount", 1); + + PRINT_SPACE + _OUT << "\"pSetLayouts\":" << std::endl; + PRINT_SPACE + if (obj.pSetLayouts) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.descriptorSetCount; i++) { + std:: stringstream tmp; + tmp << "pSetLayouts" << "_" << i; + bool isCommaNeeded = (i+1) != obj.descriptorSetCount; + print_VkDescriptorSetLayout(obj.pSetLayouts[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "descriptorPool" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj->descriptorSetCount, "descriptorSetCount", 1); + + PRINT_SPACE + _OUT << "\"pSetLayouts\":" << std::endl; + PRINT_SPACE + if (obj->pSetLayouts) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->descriptorSetCount; i++) { + std:: stringstream tmp; + tmp << "pSetLayouts" << "_" << i; + bool isCommaNeeded = (i+1) != obj->descriptorSetCount; + print_VkDescriptorSetLayout(obj->pSetLayouts[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDescriptorSetLayoutBinding(VkDescriptorSetLayoutBinding obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj.binding, "binding", 1); + + print_VkDescriptorType(obj.descriptorType, "descriptorType", 1); + + print_uint32_t(obj.descriptorCount, "descriptorCount", 1); + + print_VkShaderStageFlags(obj.stageFlags, "stageFlags", 1); + + PRINT_SPACE + _OUT << "\"pImmutableSamplers\":" << std::endl; + PRINT_SPACE + if (obj.pImmutableSamplers) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.descriptorCount; i++) { + std:: stringstream tmp; + tmp << "pImmutableSamplers" << "_" << (obj.binding) << "_" << i; + bool isCommaNeeded = (i+1) != obj.descriptorCount; + print_VkSampler(obj.pImmutableSamplers[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj->binding, "binding", 1); + + print_VkDescriptorType(obj->descriptorType, "descriptorType", 1); + + print_uint32_t(obj->descriptorCount, "descriptorCount", 1); + + print_VkShaderStageFlags(obj->stageFlags, "stageFlags", 1); + + PRINT_SPACE + _OUT << "\"pImmutableSamplers\":" << std::endl; + PRINT_SPACE + if (obj->pImmutableSamplers) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->descriptorCount; i++) { + std:: stringstream tmp; + tmp << "pImmutableSamplers" << "_" << (obj->binding) << "_" << i; + bool isCommaNeeded = (i+1) != obj->descriptorCount; + print_VkSampler(obj->pImmutableSamplers[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDescriptorSetLayoutCreateInfo(VkDescriptorSetLayoutCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDescriptorSetLayoutCreateFlags(obj.flags, "flags", 1); + + print_uint32_t(obj.bindingCount, "bindingCount", 1); + + PRINT_SPACE + _OUT << "\"pBindings\": " << std::endl; + if (obj.pBindings) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.bindingCount; i++) { + if (i+1 == obj.bindingCount) + print_VkDescriptorSetLayoutBinding(obj.pBindings[i], "pBindings", 0); + else + print_VkDescriptorSetLayoutBinding(obj.pBindings[i], "pBindings", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDescriptorSetLayoutCreateFlags(obj->flags, "flags", 1); + + print_uint32_t(obj->bindingCount, "bindingCount", 1); + + PRINT_SPACE + _OUT << "\"pBindings\": " << std::endl; + if (obj->pBindings) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->bindingCount; i++) { + if (i+1 == obj->bindingCount) + print_VkDescriptorSetLayoutBinding(obj->pBindings[i], "pBindings", 0); + else + print_VkDescriptorSetLayoutBinding(obj->pBindings[i], "pBindings", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkWriteDescriptorSet(VkWriteDescriptorSet obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "dstSet" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj.dstBinding, "dstBinding", 1); + + print_uint32_t(obj.dstArrayElement, "dstArrayElement", 1); + + print_uint32_t(obj.descriptorCount, "descriptorCount", 1); + + print_VkDescriptorType(obj.descriptorType, "descriptorType", 1); + + PRINT_SPACE + _OUT << "\"pImageInfo\": " << std::endl; + if (obj.pImageInfo) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.descriptorCount; i++) { + if (i+1 == obj.descriptorCount) + print_VkDescriptorImageInfo(obj.pImageInfo[i], "pImageInfo", 0); + else + print_VkDescriptorImageInfo(obj.pImageInfo[i], "pImageInfo", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pBufferInfo\": " << std::endl; + if (obj.pBufferInfo) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.descriptorCount; i++) { + if (i+1 == obj.descriptorCount) + print_VkDescriptorBufferInfo(obj.pBufferInfo[i], "pBufferInfo", 0); + else + print_VkDescriptorBufferInfo(obj.pBufferInfo[i], "pBufferInfo", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pTexelBufferView\":" << std::endl; + PRINT_SPACE + if (obj.pTexelBufferView) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.descriptorCount; i++) { + std:: stringstream tmp; + tmp << "pTexelBufferView" << "_" << i; + bool isCommaNeeded = (i+1) != obj.descriptorCount; + print_VkBufferView(obj.pTexelBufferView[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkWriteDescriptorSet(const VkWriteDescriptorSet * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "dstSet" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj->dstBinding, "dstBinding", 1); + + print_uint32_t(obj->dstArrayElement, "dstArrayElement", 1); + + print_uint32_t(obj->descriptorCount, "descriptorCount", 1); + + print_VkDescriptorType(obj->descriptorType, "descriptorType", 1); + + PRINT_SPACE + _OUT << "\"pImageInfo\": " << std::endl; + if (obj->pImageInfo) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->descriptorCount; i++) { + if (i+1 == obj->descriptorCount) + print_VkDescriptorImageInfo(obj->pImageInfo[i], "pImageInfo", 0); + else + print_VkDescriptorImageInfo(obj->pImageInfo[i], "pImageInfo", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pBufferInfo\": " << std::endl; + if (obj->pBufferInfo) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->descriptorCount; i++) { + if (i+1 == obj->descriptorCount) + print_VkDescriptorBufferInfo(obj->pBufferInfo[i], "pBufferInfo", 0); + else + print_VkDescriptorBufferInfo(obj->pBufferInfo[i], "pBufferInfo", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pTexelBufferView\":" << std::endl; + PRINT_SPACE + if (obj->pTexelBufferView) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->descriptorCount; i++) { + std:: stringstream tmp; + tmp << "pTexelBufferView" << "_" << i; + bool isCommaNeeded = (i+1) != obj->descriptorCount; + print_VkBufferView(obj->pTexelBufferView[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkAttachmentDescription(VkAttachmentDescription obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkAttachmentDescriptionFlags(obj.flags, "flags", 1); + + print_VkFormat(obj.format, "format", 1); + + print_VkSampleCountFlagBits(obj.samples, "samples", 1); + + print_VkAttachmentLoadOp(obj.loadOp, "loadOp", 1); + + print_VkAttachmentStoreOp(obj.storeOp, "storeOp", 1); + + print_VkAttachmentLoadOp(obj.stencilLoadOp, "stencilLoadOp", 1); + + print_VkAttachmentStoreOp(obj.stencilStoreOp, "stencilStoreOp", 1); + + print_VkImageLayout(obj.initialLayout, "initialLayout", 1); + + print_VkImageLayout(obj.finalLayout, "finalLayout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkAttachmentDescription(const VkAttachmentDescription * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkAttachmentDescriptionFlags(obj->flags, "flags", 1); + + print_VkFormat(obj->format, "format", 1); + + print_VkSampleCountFlagBits(obj->samples, "samples", 1); + + print_VkAttachmentLoadOp(obj->loadOp, "loadOp", 1); + + print_VkAttachmentStoreOp(obj->storeOp, "storeOp", 1); + + print_VkAttachmentLoadOp(obj->stencilLoadOp, "stencilLoadOp", 1); + + print_VkAttachmentStoreOp(obj->stencilStoreOp, "stencilStoreOp", 1); + + print_VkImageLayout(obj->initialLayout, "initialLayout", 1); + + print_VkImageLayout(obj->finalLayout, "finalLayout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkAttachmentReference(VkAttachmentReference obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj.attachment, "attachment", 1); + + print_VkImageLayout(obj.layout, "layout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkAttachmentReference(const VkAttachmentReference * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj->attachment, "attachment", 1); + + print_VkImageLayout(obj->layout, "layout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkFramebufferCreateInfo(VkFramebufferCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkFramebufferCreateFlags(obj.flags, "flags", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "renderPass" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj.attachmentCount, "attachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pAttachments\":" << std::endl; + PRINT_SPACE + if (obj.pAttachments) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.attachmentCount; i++) { + std:: stringstream tmp; + tmp << "pAttachments" << "_" << i; + bool isCommaNeeded = (i+1) != obj.attachmentCount; + print_VkImageView(obj.pAttachments[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj.width, "width", 1); + + print_uint32_t(obj.height, "height", 1); + + print_uint32_t(obj.layers, "layers", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkFramebufferCreateInfo(const VkFramebufferCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkFramebufferCreateFlags(obj->flags, "flags", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "renderPass" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj->attachmentCount, "attachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pAttachments\":" << std::endl; + PRINT_SPACE + if (obj->pAttachments) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->attachmentCount; i++) { + std:: stringstream tmp; + tmp << "pAttachments" << "_" << i; + bool isCommaNeeded = (i+1) != obj->attachmentCount; + print_VkImageView(obj->pAttachments[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj->width, "width", 1); + + print_uint32_t(obj->height, "height", 1); + + print_uint32_t(obj->layers, "layers", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSubpassDescription(VkSubpassDescription obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkSubpassDescriptionFlags(obj.flags, "flags", 1); + + print_VkPipelineBindPoint(obj.pipelineBindPoint, "pipelineBindPoint", 1); + + print_uint32_t(obj.inputAttachmentCount, "inputAttachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pInputAttachments\": " << std::endl; + if (obj.pInputAttachments) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.inputAttachmentCount; i++) { + if (i+1 == obj.inputAttachmentCount) + print_VkAttachmentReference(obj.pInputAttachments[i], "pInputAttachments", 0); + else + print_VkAttachmentReference(obj.pInputAttachments[i], "pInputAttachments", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.colorAttachmentCount, "colorAttachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pColorAttachments\": " << std::endl; + if (obj.pColorAttachments) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.colorAttachmentCount; i++) { + if (i+1 == obj.colorAttachmentCount) + print_VkAttachmentReference(obj.pColorAttachments[i], "pColorAttachments", 0); + else + print_VkAttachmentReference(obj.pColorAttachments[i], "pColorAttachments", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pResolveAttachments\": " << std::endl; + if (obj.pResolveAttachments) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.colorAttachmentCount; i++) { + if (i+1 == obj.colorAttachmentCount) + print_VkAttachmentReference(obj.pResolveAttachments[i], "pResolveAttachments", 0); + else + print_VkAttachmentReference(obj.pResolveAttachments[i], "pResolveAttachments", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pDepthStencilAttachment\": " << std::endl; + if (obj.pDepthStencilAttachment) { + print_VkAttachmentReference(obj.pDepthStencilAttachment, "pDepthStencilAttachment", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.preserveAttachmentCount, "preserveAttachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pPreserveAttachments\":" << std::endl; + PRINT_SPACE + if (obj.pPreserveAttachments) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.preserveAttachmentCount; i++) { + bool isCommaNeeded = (i+1) != obj.preserveAttachmentCount; + print_uint32_t(obj.pPreserveAttachments[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSubpassDescription(const VkSubpassDescription * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkSubpassDescriptionFlags(obj->flags, "flags", 1); + + print_VkPipelineBindPoint(obj->pipelineBindPoint, "pipelineBindPoint", 1); + + print_uint32_t(obj->inputAttachmentCount, "inputAttachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pInputAttachments\": " << std::endl; + if (obj->pInputAttachments) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->inputAttachmentCount; i++) { + if (i+1 == obj->inputAttachmentCount) + print_VkAttachmentReference(obj->pInputAttachments[i], "pInputAttachments", 0); + else + print_VkAttachmentReference(obj->pInputAttachments[i], "pInputAttachments", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->colorAttachmentCount, "colorAttachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pColorAttachments\": " << std::endl; + if (obj->pColorAttachments) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->colorAttachmentCount; i++) { + if (i+1 == obj->colorAttachmentCount) + print_VkAttachmentReference(obj->pColorAttachments[i], "pColorAttachments", 0); + else + print_VkAttachmentReference(obj->pColorAttachments[i], "pColorAttachments", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pResolveAttachments\": " << std::endl; + if (obj->pResolveAttachments) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->colorAttachmentCount; i++) { + if (i+1 == obj->colorAttachmentCount) + print_VkAttachmentReference(obj->pResolveAttachments[i], "pResolveAttachments", 0); + else + print_VkAttachmentReference(obj->pResolveAttachments[i], "pResolveAttachments", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pDepthStencilAttachment\": " << std::endl; + if (obj->pDepthStencilAttachment) { + print_VkAttachmentReference(obj->pDepthStencilAttachment, "pDepthStencilAttachment", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->preserveAttachmentCount, "preserveAttachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pPreserveAttachments\":" << std::endl; + PRINT_SPACE + if (obj->pPreserveAttachments) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->preserveAttachmentCount; i++) { + bool isCommaNeeded = (i+1) != obj->preserveAttachmentCount; + print_uint32_t(obj->pPreserveAttachments[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSubpassDependency(VkSubpassDependency obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj.srcSubpass, "srcSubpass", 1); + + print_uint32_t(obj.dstSubpass, "dstSubpass", 1); + + print_VkPipelineStageFlags(obj.srcStageMask, "srcStageMask", 1); + + print_VkPipelineStageFlags(obj.dstStageMask, "dstStageMask", 1); + + print_VkAccessFlags(obj.srcAccessMask, "srcAccessMask", 1); + + print_VkAccessFlags(obj.dstAccessMask, "dstAccessMask", 1); + + print_VkDependencyFlags(obj.dependencyFlags, "dependencyFlags", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSubpassDependency(const VkSubpassDependency * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj->srcSubpass, "srcSubpass", 1); + + print_uint32_t(obj->dstSubpass, "dstSubpass", 1); + + print_VkPipelineStageFlags(obj->srcStageMask, "srcStageMask", 1); + + print_VkPipelineStageFlags(obj->dstStageMask, "dstStageMask", 1); + + print_VkAccessFlags(obj->srcAccessMask, "srcAccessMask", 1); + + print_VkAccessFlags(obj->dstAccessMask, "dstAccessMask", 1); + + print_VkDependencyFlags(obj->dependencyFlags, "dependencyFlags", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkRenderPassCreateInfo(VkRenderPassCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkRenderPassCreateFlags(obj.flags, "flags", 1); + + print_uint32_t(obj.attachmentCount, "attachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pAttachments\": " << std::endl; + if (obj.pAttachments) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.attachmentCount; i++) { + if (i+1 == obj.attachmentCount) + print_VkAttachmentDescription(obj.pAttachments[i], "pAttachments", 0); + else + print_VkAttachmentDescription(obj.pAttachments[i], "pAttachments", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.subpassCount, "subpassCount", 1); + + PRINT_SPACE + _OUT << "\"pSubpasses\": " << std::endl; + if (obj.pSubpasses) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.subpassCount; i++) { + if (i+1 == obj.subpassCount) + print_VkSubpassDescription(obj.pSubpasses[i], "pSubpasses", 0); + else + print_VkSubpassDescription(obj.pSubpasses[i], "pSubpasses", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.dependencyCount, "dependencyCount", 1); + + PRINT_SPACE + _OUT << "\"pDependencies\": " << std::endl; + if (obj.pDependencies) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.dependencyCount; i++) { + if (i+1 == obj.dependencyCount) + print_VkSubpassDependency(obj.pDependencies[i], "pDependencies", 0); + else + print_VkSubpassDependency(obj.pDependencies[i], "pDependencies", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkRenderPassCreateInfo(const VkRenderPassCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkRenderPassCreateFlags(obj->flags, "flags", 1); + + print_uint32_t(obj->attachmentCount, "attachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pAttachments\": " << std::endl; + if (obj->pAttachments) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->attachmentCount; i++) { + if (i+1 == obj->attachmentCount) + print_VkAttachmentDescription(obj->pAttachments[i], "pAttachments", 0); + else + print_VkAttachmentDescription(obj->pAttachments[i], "pAttachments", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->subpassCount, "subpassCount", 1); + + PRINT_SPACE + _OUT << "\"pSubpasses\": " << std::endl; + if (obj->pSubpasses) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->subpassCount; i++) { + if (i+1 == obj->subpassCount) + print_VkSubpassDescription(obj->pSubpasses[i], "pSubpasses", 0); + else + print_VkSubpassDescription(obj->pSubpasses[i], "pSubpasses", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->dependencyCount, "dependencyCount", 1); + + PRINT_SPACE + _OUT << "\"pDependencies\": " << std::endl; + if (obj->pDependencies) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->dependencyCount; i++) { + if (i+1 == obj->dependencyCount) + print_VkSubpassDependency(obj->pDependencies[i], "pDependencies", 0); + else + print_VkSubpassDependency(obj->pDependencies[i], "pDependencies", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkCommandPoolCreateInfo(VkCommandPoolCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkCommandPoolCreateFlags(obj.flags, "flags", 1); + + print_uint32_t(obj.queueFamilyIndex, "queueFamilyIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkCommandPoolCreateFlags(obj->flags, "flags", 1); + + print_uint32_t(obj->queueFamilyIndex, "queueFamilyIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkCommandBufferAllocateInfo(VkCommandBufferAllocateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "commandPool" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkCommandBufferLevel(obj.level, "level", 1); + + print_uint32_t(obj.commandBufferCount, "commandBufferCount", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "commandPool" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkCommandBufferLevel(obj->level, "level", 1); + + print_uint32_t(obj->commandBufferCount, "commandBufferCount", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkCommandBufferInheritanceInfo(VkCommandBufferInheritanceInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "renderPass" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj.subpass, "subpass", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "framebuffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkBool32(obj.occlusionQueryEnable, "occlusionQueryEnable", 1); + + print_VkQueryControlFlags(obj.queryFlags, "queryFlags", 1); + + print_VkQueryPipelineStatisticFlags(obj.pipelineStatistics, "pipelineStatistics", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "renderPass" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj->subpass, "subpass", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "framebuffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkBool32(obj->occlusionQueryEnable, "occlusionQueryEnable", 1); + + print_VkQueryControlFlags(obj->queryFlags, "queryFlags", 1); + + print_VkQueryPipelineStatisticFlags(obj->pipelineStatistics, "pipelineStatistics", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkCommandBufferBeginInfo(VkCommandBufferBeginInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkCommandBufferUsageFlags(obj.flags, "flags", 1); + + PRINT_SPACE + _OUT << "\"pInheritanceInfo\": " << std::endl; + if (obj.pInheritanceInfo) { + print_VkCommandBufferInheritanceInfo(obj.pInheritanceInfo, "pInheritanceInfo", 0); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkCommandBufferUsageFlags(obj->flags, "flags", 1); + + PRINT_SPACE + _OUT << "\"pInheritanceInfo\": " << std::endl; + if (obj->pInheritanceInfo) { + print_VkCommandBufferInheritanceInfo(obj->pInheritanceInfo, "pInheritanceInfo", 0); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkBufferCopy(VkBufferCopy obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkDeviceSize(obj.srcOffset, "srcOffset", 1); + + print_VkDeviceSize(obj.dstOffset, "dstOffset", 1); + + print_VkDeviceSize(obj.size, "size", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkBufferCopy(const VkBufferCopy * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkDeviceSize(obj->srcOffset, "srcOffset", 1); + + print_VkDeviceSize(obj->dstOffset, "dstOffset", 1); + + print_VkDeviceSize(obj->size, "size", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageSubresourceLayers(VkImageSubresourceLayers obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkImageAspectFlags(obj.aspectMask, "aspectMask", 1); + + print_uint32_t(obj.mipLevel, "mipLevel", 1); + + print_uint32_t(obj.baseArrayLayer, "baseArrayLayer", 1); + + print_uint32_t(obj.layerCount, "layerCount", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageSubresourceLayers(const VkImageSubresourceLayers * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkImageAspectFlags(obj->aspectMask, "aspectMask", 1); + + print_uint32_t(obj->mipLevel, "mipLevel", 1); + + print_uint32_t(obj->baseArrayLayer, "baseArrayLayer", 1); + + print_uint32_t(obj->layerCount, "layerCount", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkBufferImageCopy(VkBufferImageCopy obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkDeviceSize(obj.bufferOffset, "bufferOffset", 1); + + print_uint32_t(obj.bufferRowLength, "bufferRowLength", 1); + + print_uint32_t(obj.bufferImageHeight, "bufferImageHeight", 1); + + PRINT_SPACE + _OUT << "\"imageSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj.imageSubresource, "imageSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"imageOffset\": " << std::endl; + { + print_VkOffset3D(obj.imageOffset, "imageOffset", 1); + } + + PRINT_SPACE + _OUT << "\"imageExtent\": " << std::endl; + { + print_VkExtent3D(obj.imageExtent, "imageExtent", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkBufferImageCopy(const VkBufferImageCopy * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkDeviceSize(obj->bufferOffset, "bufferOffset", 1); + + print_uint32_t(obj->bufferRowLength, "bufferRowLength", 1); + + print_uint32_t(obj->bufferImageHeight, "bufferImageHeight", 1); + + PRINT_SPACE + _OUT << "\"imageSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj->imageSubresource, "imageSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"imageOffset\": " << std::endl; + { + print_VkOffset3D(obj->imageOffset, "imageOffset", 1); + } + + PRINT_SPACE + _OUT << "\"imageExtent\": " << std::endl; + { + print_VkExtent3D(obj->imageExtent, "imageExtent", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkClearColorValue(VkClearColorValue obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"float32\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 4; i++) { + bool isCommaNeeded = (i+1) != 4; + print_float(obj.float32[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"int32\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 4; i++) { + bool isCommaNeeded = (i+1) != 4; + print_int32_t(obj.int32[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"uint32\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 4; i++) { + bool isCommaNeeded = (i+1) != 4; + print_uint32_t(obj.uint32[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkClearColorValue(const VkClearColorValue * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"float32\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 4; i++) { + bool isCommaNeeded = (i+1) != 4; + print_float(obj->float32[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"int32\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 4; i++) { + bool isCommaNeeded = (i+1) != 4; + print_int32_t(obj->int32[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"uint32\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 4; i++) { + bool isCommaNeeded = (i+1) != 4; + print_uint32_t(obj->uint32[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkClearDepthStencilValue(VkClearDepthStencilValue obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_float(obj.depth, "depth", 1); + + print_uint32_t(obj.stencil, "stencil", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkClearDepthStencilValue(const VkClearDepthStencilValue * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_float(obj->depth, "depth", 1); + + print_uint32_t(obj->stencil, "stencil", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkClearValue(VkClearValue obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkClearColorValue(obj.color, "color", 1); + + PRINT_SPACE + _OUT << "\"depthStencil\": " << std::endl; + { + print_VkClearDepthStencilValue(obj.depthStencil, "depthStencil", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkClearValue(const VkClearValue * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkClearColorValue(obj->color, "color", 1); + + PRINT_SPACE + _OUT << "\"depthStencil\": " << std::endl; + { + print_VkClearDepthStencilValue(obj->depthStencil, "depthStencil", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkClearAttachment(VkClearAttachment obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkImageAspectFlags(obj.aspectMask, "aspectMask", 1); + + print_uint32_t(obj.colorAttachment, "colorAttachment", 1); + + print_VkClearValue(obj.clearValue, "clearValue", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkClearAttachment(const VkClearAttachment * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkImageAspectFlags(obj->aspectMask, "aspectMask", 1); + + print_uint32_t(obj->colorAttachment, "colorAttachment", 1); + + print_VkClearValue(obj->clearValue, "clearValue", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkClearRect(VkClearRect obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"rect\": " << std::endl; + { + print_VkRect2D(obj.rect, "rect", 1); + } + + print_uint32_t(obj.baseArrayLayer, "baseArrayLayer", 1); + + print_uint32_t(obj.layerCount, "layerCount", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkClearRect(const VkClearRect * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"rect\": " << std::endl; + { + print_VkRect2D(obj->rect, "rect", 1); + } + + print_uint32_t(obj->baseArrayLayer, "baseArrayLayer", 1); + + print_uint32_t(obj->layerCount, "layerCount", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageBlit(VkImageBlit obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"srcSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj.srcSubresource, "srcSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"srcOffsets\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 2; i++) { + bool isCommaNeeded = (i+1) != 2; + print_VkOffset3D(obj.srcOffsets[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"dstSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj.dstSubresource, "dstSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"dstOffsets\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 2; i++) { + bool isCommaNeeded = (i+1) != 2; + print_VkOffset3D(obj.dstOffsets[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageBlit(const VkImageBlit * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"srcSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj->srcSubresource, "srcSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"srcOffsets\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 2; i++) { + bool isCommaNeeded = (i+1) != 2; + print_VkOffset3D(obj->srcOffsets[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"dstSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj->dstSubresource, "dstSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"dstOffsets\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 2; i++) { + bool isCommaNeeded = (i+1) != 2; + print_VkOffset3D(obj->dstOffsets[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageCopy(VkImageCopy obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"srcSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj.srcSubresource, "srcSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"srcOffset\": " << std::endl; + { + print_VkOffset3D(obj.srcOffset, "srcOffset", 1); + } + + PRINT_SPACE + _OUT << "\"dstSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj.dstSubresource, "dstSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"dstOffset\": " << std::endl; + { + print_VkOffset3D(obj.dstOffset, "dstOffset", 1); + } + + PRINT_SPACE + _OUT << "\"extent\": " << std::endl; + { + print_VkExtent3D(obj.extent, "extent", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageCopy(const VkImageCopy * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"srcSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj->srcSubresource, "srcSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"srcOffset\": " << std::endl; + { + print_VkOffset3D(obj->srcOffset, "srcOffset", 1); + } + + PRINT_SPACE + _OUT << "\"dstSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj->dstSubresource, "dstSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"dstOffset\": " << std::endl; + { + print_VkOffset3D(obj->dstOffset, "dstOffset", 1); + } + + PRINT_SPACE + _OUT << "\"extent\": " << std::endl; + { + print_VkExtent3D(obj->extent, "extent", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageResolve(VkImageResolve obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"srcSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj.srcSubresource, "srcSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"srcOffset\": " << std::endl; + { + print_VkOffset3D(obj.srcOffset, "srcOffset", 1); + } + + PRINT_SPACE + _OUT << "\"dstSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj.dstSubresource, "dstSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"dstOffset\": " << std::endl; + { + print_VkOffset3D(obj.dstOffset, "dstOffset", 1); + } + + PRINT_SPACE + _OUT << "\"extent\": " << std::endl; + { + print_VkExtent3D(obj.extent, "extent", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageResolve(const VkImageResolve * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"srcSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj->srcSubresource, "srcSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"srcOffset\": " << std::endl; + { + print_VkOffset3D(obj->srcOffset, "srcOffset", 1); + } + + PRINT_SPACE + _OUT << "\"dstSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj->dstSubresource, "dstSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"dstOffset\": " << std::endl; + { + print_VkOffset3D(obj->dstOffset, "dstOffset", 1); + } + + PRINT_SPACE + _OUT << "\"extent\": " << std::endl; + { + print_VkExtent3D(obj->extent, "extent", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkRenderPassBeginInfo(VkRenderPassBeginInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "renderPass" << "\"" << " : " << "\"" << "\"," << std::endl; + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "framebuffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + PRINT_SPACE + _OUT << "\"renderArea\": " << std::endl; + { + print_VkRect2D(obj.renderArea, "renderArea", 1); + } + + print_uint32_t(obj.clearValueCount, "clearValueCount", 1); + + PRINT_SPACE + _OUT << "\"pClearValues\":" << std::endl; + PRINT_SPACE + if (obj.pClearValues) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.clearValueCount; i++) { + bool isCommaNeeded = (i+1) != obj.clearValueCount; + print_VkClearValue(obj.pClearValues[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkRenderPassBeginInfo(const VkRenderPassBeginInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "renderPass" << "\"" << " : " << "\"" << "\"," << std::endl; + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "framebuffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + PRINT_SPACE + _OUT << "\"renderArea\": " << std::endl; + { + print_VkRect2D(obj->renderArea, "renderArea", 1); + } + + print_uint32_t(obj->clearValueCount, "clearValueCount", 1); + + PRINT_SPACE + _OUT << "\"pClearValues\":" << std::endl; + PRINT_SPACE + if (obj->pClearValues) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->clearValueCount; i++) { + bool isCommaNeeded = (i+1) != obj->clearValueCount; + print_VkClearValue(obj->pClearValues[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSamplerYcbcrConversion(VkSamplerYcbcrConversion obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkSamplerYcbcrConversion(const VkSamplerYcbcrConversion * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static std::map VkSubgroupFeatureFlagBits_map = { + std::make_pair(1ULL << 0, "VK_SUBGROUP_FEATURE_BASIC_BIT"), + std::make_pair(1ULL << 1, "VK_SUBGROUP_FEATURE_VOTE_BIT"), + std::make_pair(1ULL << 2, "VK_SUBGROUP_FEATURE_ARITHMETIC_BIT"), + std::make_pair(1ULL << 3, "VK_SUBGROUP_FEATURE_BALLOT_BIT"), + std::make_pair(1ULL << 4, "VK_SUBGROUP_FEATURE_SHUFFLE_BIT"), + std::make_pair(1ULL << 5, "VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT"), + std::make_pair(1ULL << 6, "VK_SUBGROUP_FEATURE_CLUSTERED_BIT"), + std::make_pair(1ULL << 7, "VK_SUBGROUP_FEATURE_QUAD_BIT"), + std::make_pair(1ULL << 8, "VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV"), +}; +static void print_VkSubgroupFeatureFlagBits(VkSubgroupFeatureFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSubgroupFeatureFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSubgroupFeatureFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkSubgroupFeatureFlagBits(const VkSubgroupFeatureFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSubgroupFeatureFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSubgroupFeatureFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkPeerMemoryFeatureFlagBits_map = { + std::make_pair(1ULL << 0, "VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT"), + std::make_pair(1ULL << 1, "VK_PEER_MEMORY_FEATURE_COPY_DST_BIT"), + std::make_pair(1ULL << 2, "VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT"), + std::make_pair(1ULL << 3, "VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT"), +}; +static void print_VkPeerMemoryFeatureFlagBits(VkPeerMemoryFeatureFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPeerMemoryFeatureFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPeerMemoryFeatureFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkPeerMemoryFeatureFlagBits(const VkPeerMemoryFeatureFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPeerMemoryFeatureFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPeerMemoryFeatureFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkMemoryAllocateFlagBits_map = { + std::make_pair(1ULL << 0, "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT"), + std::make_pair(1ULL << 1, "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT"), + std::make_pair(1ULL << 2, "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT"), +}; +static void print_VkMemoryAllocateFlagBits(VkMemoryAllocateFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkMemoryAllocateFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkMemoryAllocateFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkMemoryAllocateFlagBits(const VkMemoryAllocateFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkMemoryAllocateFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkMemoryAllocateFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkPointClippingBehavior_map = { + std::make_pair(0, "VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES"), + std::make_pair(1, "VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY"), +}; +static void print_VkPointClippingBehavior(VkPointClippingBehavior obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPointClippingBehavior_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPointClippingBehavior_map[obj] << "\"" << std::endl; +} +static void print_VkPointClippingBehavior(const VkPointClippingBehavior * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPointClippingBehavior_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPointClippingBehavior_map[*obj] << "\"" << std::endl; +} + +static std::map VkTessellationDomainOrigin_map = { + std::make_pair(0, "VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT"), + std::make_pair(1, "VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT"), +}; +static void print_VkTessellationDomainOrigin(VkTessellationDomainOrigin obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkTessellationDomainOrigin_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkTessellationDomainOrigin_map[obj] << "\"" << std::endl; +} +static void print_VkTessellationDomainOrigin(const VkTessellationDomainOrigin * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkTessellationDomainOrigin_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkTessellationDomainOrigin_map[*obj] << "\"" << std::endl; +} + +static std::map VkSamplerYcbcrModelConversion_map = { + std::make_pair(0, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY"), + std::make_pair(1, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY"), + std::make_pair(2, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709"), + std::make_pair(3, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601"), + std::make_pair(4, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020"), +}; +static void print_VkSamplerYcbcrModelConversion(VkSamplerYcbcrModelConversion obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSamplerYcbcrModelConversion_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSamplerYcbcrModelConversion_map[obj] << "\"" << std::endl; +} +static void print_VkSamplerYcbcrModelConversion(const VkSamplerYcbcrModelConversion * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSamplerYcbcrModelConversion_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSamplerYcbcrModelConversion_map[*obj] << "\"" << std::endl; +} + +static std::map VkSamplerYcbcrRange_map = { + std::make_pair(0, "VK_SAMPLER_YCBCR_RANGE_ITU_FULL"), + std::make_pair(1, "VK_SAMPLER_YCBCR_RANGE_ITU_NARROW"), +}; +static void print_VkSamplerYcbcrRange(VkSamplerYcbcrRange obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSamplerYcbcrRange_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSamplerYcbcrRange_map[obj] << "\"" << std::endl; +} +static void print_VkSamplerYcbcrRange(const VkSamplerYcbcrRange * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSamplerYcbcrRange_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSamplerYcbcrRange_map[*obj] << "\"" << std::endl; +} + +static std::map VkChromaLocation_map = { + std::make_pair(0, "VK_CHROMA_LOCATION_COSITED_EVEN"), + std::make_pair(1, "VK_CHROMA_LOCATION_MIDPOINT"), +}; +static void print_VkChromaLocation(VkChromaLocation obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkChromaLocation_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkChromaLocation_map[obj] << "\"" << std::endl; +} +static void print_VkChromaLocation(const VkChromaLocation * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkChromaLocation_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkChromaLocation_map[*obj] << "\"" << std::endl; +} + +static std::map VkExternalMemoryHandleTypeFlagBits_map = { + std::make_pair(1ULL << 0, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT"), + std::make_pair(1ULL << 1, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT"), + std::make_pair(1ULL << 2, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"), + std::make_pair(1ULL << 3, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT"), + std::make_pair(1ULL << 4, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT"), + std::make_pair(1ULL << 5, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT"), + std::make_pair(1ULL << 6, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT"), + std::make_pair(1ULL << 9, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT"), + std::make_pair(1ULL << 10, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID"), + std::make_pair(1ULL << 7, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT"), + std::make_pair(1ULL << 8, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT"), + std::make_pair(1ULL << 11, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA"), + std::make_pair(1ULL << 12, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV"), + std::make_pair(1ULL << 13, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_RESERVED_13_BIT_NV"), +}; +static void print_VkExternalMemoryHandleTypeFlagBits(VkExternalMemoryHandleTypeFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkExternalMemoryHandleTypeFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkExternalMemoryHandleTypeFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkExternalMemoryHandleTypeFlagBits(const VkExternalMemoryHandleTypeFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkExternalMemoryHandleTypeFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkExternalMemoryHandleTypeFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkExternalMemoryFeatureFlagBits_map = { + std::make_pair(1ULL << 0, "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT"), + std::make_pair(1ULL << 1, "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT"), + std::make_pair(1ULL << 2, "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT"), +}; +static void print_VkExternalMemoryFeatureFlagBits(VkExternalMemoryFeatureFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkExternalMemoryFeatureFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkExternalMemoryFeatureFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkExternalMemoryFeatureFlagBits(const VkExternalMemoryFeatureFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkExternalMemoryFeatureFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkExternalMemoryFeatureFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkExternalFenceHandleTypeFlagBits_map = { + std::make_pair(1ULL << 0, "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT"), + std::make_pair(1ULL << 1, "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT"), + std::make_pair(1ULL << 2, "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"), + std::make_pair(1ULL << 3, "VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT"), + std::make_pair(1ULL << 4, "VK_EXTERNAL_FENCE_HANDLE_TYPE_RESERVED_4_BIT_NV"), + std::make_pair(1ULL << 5, "VK_EXTERNAL_FENCE_HANDLE_TYPE_RESERVED_5_BIT_NV"), +}; +static void print_VkExternalFenceHandleTypeFlagBits(VkExternalFenceHandleTypeFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkExternalFenceHandleTypeFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkExternalFenceHandleTypeFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkExternalFenceHandleTypeFlagBits(const VkExternalFenceHandleTypeFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkExternalFenceHandleTypeFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkExternalFenceHandleTypeFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkExternalFenceFeatureFlagBits_map = { + std::make_pair(1ULL << 0, "VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT"), + std::make_pair(1ULL << 1, "VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT"), +}; +static void print_VkExternalFenceFeatureFlagBits(VkExternalFenceFeatureFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkExternalFenceFeatureFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkExternalFenceFeatureFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkExternalFenceFeatureFlagBits(const VkExternalFenceFeatureFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkExternalFenceFeatureFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkExternalFenceFeatureFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkFenceImportFlagBits_map = { + std::make_pair(1ULL << 0, "VK_FENCE_IMPORT_TEMPORARY_BIT"), +}; +static void print_VkFenceImportFlagBits(VkFenceImportFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFenceImportFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFenceImportFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkFenceImportFlagBits(const VkFenceImportFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFenceImportFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFenceImportFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkSemaphoreImportFlagBits_map = { + std::make_pair(1ULL << 0, "VK_SEMAPHORE_IMPORT_TEMPORARY_BIT"), +}; +static void print_VkSemaphoreImportFlagBits(VkSemaphoreImportFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSemaphoreImportFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSemaphoreImportFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkSemaphoreImportFlagBits(const VkSemaphoreImportFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSemaphoreImportFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSemaphoreImportFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkExternalSemaphoreHandleTypeFlagBits_map = { + std::make_pair(1ULL << 0, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT"), + std::make_pair(1ULL << 1, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT"), + std::make_pair(1ULL << 2, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"), + std::make_pair(1ULL << 3, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT"), + std::make_pair(1ULL << 4, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT"), + std::make_pair(1ULL << 7, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA"), + std::make_pair(1ULL << 5, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_RESERVED_5_BIT_NV"), + std::make_pair(1ULL << 6, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_RESERVED_6_BIT_NV"), +}; +static void print_VkExternalSemaphoreHandleTypeFlagBits(VkExternalSemaphoreHandleTypeFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkExternalSemaphoreHandleTypeFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkExternalSemaphoreHandleTypeFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkExternalSemaphoreHandleTypeFlagBits(const VkExternalSemaphoreHandleTypeFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkExternalSemaphoreHandleTypeFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkExternalSemaphoreHandleTypeFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkExternalSemaphoreFeatureFlagBits_map = { + std::make_pair(1ULL << 0, "VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT"), + std::make_pair(1ULL << 1, "VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT"), +}; +static void print_VkExternalSemaphoreFeatureFlagBits(VkExternalSemaphoreFeatureFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkExternalSemaphoreFeatureFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkExternalSemaphoreFeatureFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkExternalSemaphoreFeatureFlagBits(const VkExternalSemaphoreFeatureFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkExternalSemaphoreFeatureFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkExternalSemaphoreFeatureFlagBits_map[*obj] << "\"" << std::endl; +} + +static void print_VkSubgroupFeatureFlags(VkSubgroupFeatureFlags obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + const int max_bits = 64; // We don't expect the number to be larger. + std::bitset b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkSubgroupFeatureFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkSubgroupFeatureFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkPeerMemoryFeatureFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkPeerMemoryFeatureFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkMemoryAllocateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkMemoryAllocateFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkExternalMemoryHandleTypeFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkExternalMemoryHandleTypeFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkExternalMemoryFeatureFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkExternalMemoryFeatureFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkExternalFenceHandleTypeFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkExternalFenceHandleTypeFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkExternalFenceFeatureFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkExternalFenceFeatureFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkFenceImportFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkFenceImportFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkSemaphoreImportFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkSemaphoreImportFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkExternalSemaphoreHandleTypeFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkExternalSemaphoreHandleTypeFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkExternalSemaphoreFeatureFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkExternalSemaphoreFeatureFlagBits_map[1ULL<sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->subgroupSize, "subgroupSize", 1); + + print_VkShaderStageFlags(obj->supportedStages, "supportedStages", 1); + + print_VkSubgroupFeatureFlags(obj->supportedOperations, "supportedOperations", 1); + + print_VkBool32(obj->quadOperationsInAllStages, "quadOperationsInAllStages", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkBindBufferMemoryInfo(VkBindBufferMemoryInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "memory" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkDeviceSize(obj.memoryOffset, "memoryOffset", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "memory" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkDeviceSize(obj->memoryOffset, "memoryOffset", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkBindImageMemoryInfo(VkBindImageMemoryInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"," << std::endl; + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "memory" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkDeviceSize(obj.memoryOffset, "memoryOffset", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkBindImageMemoryInfo(const VkBindImageMemoryInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"," << std::endl; + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "memory" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkDeviceSize(obj->memoryOffset, "memoryOffset", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDevice16BitStorageFeatures(VkPhysicalDevice16BitStorageFeatures obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.storageBuffer16BitAccess, "storageBuffer16BitAccess", 1); + + print_VkBool32(obj.uniformAndStorageBuffer16BitAccess, "uniformAndStorageBuffer16BitAccess", 1); + + print_VkBool32(obj.storagePushConstant16, "storagePushConstant16", 1); + + print_VkBool32(obj.storageInputOutput16, "storageInputOutput16", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->storageBuffer16BitAccess, "storageBuffer16BitAccess", 1); + + print_VkBool32(obj->uniformAndStorageBuffer16BitAccess, "uniformAndStorageBuffer16BitAccess", 1); + + print_VkBool32(obj->storagePushConstant16, "storagePushConstant16", 1); + + print_VkBool32(obj->storageInputOutput16, "storageInputOutput16", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkMemoryDedicatedRequirements(VkMemoryDedicatedRequirements obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.prefersDedicatedAllocation, "prefersDedicatedAllocation", 1); + + print_VkBool32(obj.requiresDedicatedAllocation, "requiresDedicatedAllocation", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->prefersDedicatedAllocation, "prefersDedicatedAllocation", 1); + + print_VkBool32(obj->requiresDedicatedAllocation, "requiresDedicatedAllocation", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkMemoryDedicatedAllocateInfo(VkMemoryDedicatedAllocateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"," << std::endl; + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"," << std::endl; + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkMemoryAllocateFlagsInfo(VkMemoryAllocateFlagsInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkMemoryAllocateFlags(obj.flags, "flags", 1); + + print_uint32_t(obj.deviceMask, "deviceMask", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkMemoryAllocateFlags(obj->flags, "flags", 1); + + print_uint32_t(obj->deviceMask, "deviceMask", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDeviceGroupRenderPassBeginInfo(VkDeviceGroupRenderPassBeginInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.deviceMask, "deviceMask", 1); + + print_uint32_t(obj.deviceRenderAreaCount, "deviceRenderAreaCount", 1); + + PRINT_SPACE + _OUT << "\"pDeviceRenderAreas\": " << std::endl; + if (obj.pDeviceRenderAreas) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.deviceRenderAreaCount; i++) { + if (i+1 == obj.deviceRenderAreaCount) + print_VkRect2D(obj.pDeviceRenderAreas[i], "pDeviceRenderAreas", 0); + else + print_VkRect2D(obj.pDeviceRenderAreas[i], "pDeviceRenderAreas", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->deviceMask, "deviceMask", 1); + + print_uint32_t(obj->deviceRenderAreaCount, "deviceRenderAreaCount", 1); + + PRINT_SPACE + _OUT << "\"pDeviceRenderAreas\": " << std::endl; + if (obj->pDeviceRenderAreas) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->deviceRenderAreaCount; i++) { + if (i+1 == obj->deviceRenderAreaCount) + print_VkRect2D(obj->pDeviceRenderAreas[i], "pDeviceRenderAreas", 0); + else + print_VkRect2D(obj->pDeviceRenderAreas[i], "pDeviceRenderAreas", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDeviceGroupCommandBufferBeginInfo(VkDeviceGroupCommandBufferBeginInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.deviceMask, "deviceMask", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->deviceMask, "deviceMask", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDeviceGroupSubmitInfo(VkDeviceGroupSubmitInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.waitSemaphoreCount, "waitSemaphoreCount", 1); + + PRINT_SPACE + _OUT << "\"pWaitSemaphoreDeviceIndices\":" << std::endl; + PRINT_SPACE + if (obj.pWaitSemaphoreDeviceIndices) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.waitSemaphoreCount; i++) { + bool isCommaNeeded = (i+1) != obj.waitSemaphoreCount; + print_uint32_t(obj.pWaitSemaphoreDeviceIndices[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj.commandBufferCount, "commandBufferCount", 1); + + PRINT_SPACE + _OUT << "\"pCommandBufferDeviceMasks\":" << std::endl; + PRINT_SPACE + if (obj.pCommandBufferDeviceMasks) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.commandBufferCount; i++) { + bool isCommaNeeded = (i+1) != obj.commandBufferCount; + print_uint32_t(obj.pCommandBufferDeviceMasks[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj.signalSemaphoreCount, "signalSemaphoreCount", 1); + + PRINT_SPACE + _OUT << "\"pSignalSemaphoreDeviceIndices\":" << std::endl; + PRINT_SPACE + if (obj.pSignalSemaphoreDeviceIndices) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.signalSemaphoreCount; i++) { + bool isCommaNeeded = (i+1) != obj.signalSemaphoreCount; + print_uint32_t(obj.pSignalSemaphoreDeviceIndices[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->waitSemaphoreCount, "waitSemaphoreCount", 1); + + PRINT_SPACE + _OUT << "\"pWaitSemaphoreDeviceIndices\":" << std::endl; + PRINT_SPACE + if (obj->pWaitSemaphoreDeviceIndices) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->waitSemaphoreCount; i++) { + bool isCommaNeeded = (i+1) != obj->waitSemaphoreCount; + print_uint32_t(obj->pWaitSemaphoreDeviceIndices[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj->commandBufferCount, "commandBufferCount", 1); + + PRINT_SPACE + _OUT << "\"pCommandBufferDeviceMasks\":" << std::endl; + PRINT_SPACE + if (obj->pCommandBufferDeviceMasks) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->commandBufferCount; i++) { + bool isCommaNeeded = (i+1) != obj->commandBufferCount; + print_uint32_t(obj->pCommandBufferDeviceMasks[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj->signalSemaphoreCount, "signalSemaphoreCount", 1); + + PRINT_SPACE + _OUT << "\"pSignalSemaphoreDeviceIndices\":" << std::endl; + PRINT_SPACE + if (obj->pSignalSemaphoreDeviceIndices) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->signalSemaphoreCount; i++) { + bool isCommaNeeded = (i+1) != obj->signalSemaphoreCount; + print_uint32_t(obj->pSignalSemaphoreDeviceIndices[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkBindBufferMemoryDeviceGroupInfo(VkBindBufferMemoryDeviceGroupInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.deviceIndexCount, "deviceIndexCount", 1); + + PRINT_SPACE + _OUT << "\"pDeviceIndices\":" << std::endl; + PRINT_SPACE + if (obj.pDeviceIndices) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.deviceIndexCount; i++) { + bool isCommaNeeded = (i+1) != obj.deviceIndexCount; + print_uint32_t(obj.pDeviceIndices[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->deviceIndexCount, "deviceIndexCount", 1); + + PRINT_SPACE + _OUT << "\"pDeviceIndices\":" << std::endl; + PRINT_SPACE + if (obj->pDeviceIndices) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->deviceIndexCount; i++) { + bool isCommaNeeded = (i+1) != obj->deviceIndexCount; + print_uint32_t(obj->pDeviceIndices[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkBindImageMemoryDeviceGroupInfo(VkBindImageMemoryDeviceGroupInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.deviceIndexCount, "deviceIndexCount", 1); + + PRINT_SPACE + _OUT << "\"pDeviceIndices\":" << std::endl; + PRINT_SPACE + if (obj.pDeviceIndices) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.deviceIndexCount; i++) { + bool isCommaNeeded = (i+1) != obj.deviceIndexCount; + print_uint32_t(obj.pDeviceIndices[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj.splitInstanceBindRegionCount, "splitInstanceBindRegionCount", 1); + + PRINT_SPACE + _OUT << "\"pSplitInstanceBindRegions\": " << std::endl; + if (obj.pSplitInstanceBindRegions) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.splitInstanceBindRegionCount; i++) { + if (i+1 == obj.splitInstanceBindRegionCount) + print_VkRect2D(obj.pSplitInstanceBindRegions[i], "pSplitInstanceBindRegions", 0); + else + print_VkRect2D(obj.pSplitInstanceBindRegions[i], "pSplitInstanceBindRegions", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->deviceIndexCount, "deviceIndexCount", 1); + + PRINT_SPACE + _OUT << "\"pDeviceIndices\":" << std::endl; + PRINT_SPACE + if (obj->pDeviceIndices) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->deviceIndexCount; i++) { + bool isCommaNeeded = (i+1) != obj->deviceIndexCount; + print_uint32_t(obj->pDeviceIndices[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj->splitInstanceBindRegionCount, "splitInstanceBindRegionCount", 1); + + PRINT_SPACE + _OUT << "\"pSplitInstanceBindRegions\": " << std::endl; + if (obj->pSplitInstanceBindRegions) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->splitInstanceBindRegionCount; i++) { + if (i+1 == obj->splitInstanceBindRegionCount) + print_VkRect2D(obj->pSplitInstanceBindRegions[i], "pSplitInstanceBindRegions", 0); + else + print_VkRect2D(obj->pSplitInstanceBindRegions[i], "pSplitInstanceBindRegions", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceGroupProperties(VkPhysicalDeviceGroupProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.physicalDeviceCount, "physicalDeviceCount", 1); + + PRINT_SPACE + _OUT << "\"physicalDevices\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++) { + std:: stringstream tmp; + tmp << "physicalDevices" << "_" << i; + bool isCommaNeeded = (i+1) != VK_MAX_DEVICE_GROUP_SIZE; + print_VkPhysicalDevice(obj.physicalDevices[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_VkBool32(obj.subsetAllocation, "subsetAllocation", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->physicalDeviceCount, "physicalDeviceCount", 1); + + PRINT_SPACE + _OUT << "\"physicalDevices\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++) { + std:: stringstream tmp; + tmp << "physicalDevices" << "_" << i; + bool isCommaNeeded = (i+1) != VK_MAX_DEVICE_GROUP_SIZE; + print_VkPhysicalDevice(obj->physicalDevices[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_VkBool32(obj->subsetAllocation, "subsetAllocation", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDeviceGroupDeviceCreateInfo(VkDeviceGroupDeviceCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.physicalDeviceCount, "physicalDeviceCount", 1); + + PRINT_SPACE + _OUT << "\"pPhysicalDevices\":" << std::endl; + PRINT_SPACE + if (obj.pPhysicalDevices) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.physicalDeviceCount; i++) { + std:: stringstream tmp; + tmp << "pPhysicalDevices" << "_" << i; + bool isCommaNeeded = (i+1) != obj.physicalDeviceCount; + print_VkPhysicalDevice(obj.pPhysicalDevices[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->physicalDeviceCount, "physicalDeviceCount", 1); + + PRINT_SPACE + _OUT << "\"pPhysicalDevices\":" << std::endl; + PRINT_SPACE + if (obj->pPhysicalDevices) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->physicalDeviceCount; i++) { + std:: stringstream tmp; + tmp << "pPhysicalDevices" << "_" << i; + bool isCommaNeeded = (i+1) != obj->physicalDeviceCount; + print_VkPhysicalDevice(obj->pPhysicalDevices[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkBufferMemoryRequirementsInfo2(VkBufferMemoryRequirementsInfo2 obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2 * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageMemoryRequirementsInfo2(VkImageMemoryRequirementsInfo2 obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2 * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkMemoryRequirements2(VkMemoryRequirements2 obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"memoryRequirements\": " << std::endl; + { + print_VkMemoryRequirements(obj.memoryRequirements, "memoryRequirements", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkMemoryRequirements2(const VkMemoryRequirements2 * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"memoryRequirements\": " << std::endl; + { + print_VkMemoryRequirements(obj->memoryRequirements, "memoryRequirements", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceFeatures2(VkPhysicalDeviceFeatures2 obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"features\": " << std::endl; + { + print_VkPhysicalDeviceFeatures(obj.features, "features", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2 * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"features\": " << std::endl; + { + print_VkPhysicalDeviceFeatures(obj->features, "features", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceProperties2(VkPhysicalDeviceProperties2 obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"properties\": " << std::endl; + { + print_VkPhysicalDeviceProperties(obj.properties, "properties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2 * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"properties\": " << std::endl; + { + print_VkPhysicalDeviceProperties(obj->properties, "properties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkFormatProperties2(VkFormatProperties2 obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"formatProperties\": " << std::endl; + { + print_VkFormatProperties(obj.formatProperties, "formatProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkFormatProperties2(const VkFormatProperties2 * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"formatProperties\": " << std::endl; + { + print_VkFormatProperties(obj->formatProperties, "formatProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageFormatProperties2(VkImageFormatProperties2 obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"imageFormatProperties\": " << std::endl; + { + print_VkImageFormatProperties(obj.imageFormatProperties, "imageFormatProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageFormatProperties2(const VkImageFormatProperties2 * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"imageFormatProperties\": " << std::endl; + { + print_VkImageFormatProperties(obj->imageFormatProperties, "imageFormatProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceImageFormatInfo2(VkPhysicalDeviceImageFormatInfo2 obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkFormat(obj.format, "format", 1); + + print_VkImageType(obj.type, "type", 1); + + print_VkImageTiling(obj.tiling, "tiling", 1); + + print_VkImageUsageFlags(obj.usage, "usage", 1); + + print_VkImageCreateFlags(obj.flags, "flags", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2 * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkFormat(obj->format, "format", 1); + + print_VkImageType(obj->type, "type", 1); + + print_VkImageTiling(obj->tiling, "tiling", 1); + + print_VkImageUsageFlags(obj->usage, "usage", 1); + + print_VkImageCreateFlags(obj->flags, "flags", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkQueueFamilyProperties2(VkQueueFamilyProperties2 obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"queueFamilyProperties\": " << std::endl; + { + print_VkQueueFamilyProperties(obj.queueFamilyProperties, "queueFamilyProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkQueueFamilyProperties2(const VkQueueFamilyProperties2 * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"queueFamilyProperties\": " << std::endl; + { + print_VkQueueFamilyProperties(obj->queueFamilyProperties, "queueFamilyProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceMemoryProperties2(VkPhysicalDeviceMemoryProperties2 obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"memoryProperties\": " << std::endl; + { + print_VkPhysicalDeviceMemoryProperties(obj.memoryProperties, "memoryProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2 * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"memoryProperties\": " << std::endl; + { + print_VkPhysicalDeviceMemoryProperties(obj->memoryProperties, "memoryProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDevicePointClippingProperties(VkPhysicalDevicePointClippingProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPointClippingBehavior(obj.pointClippingBehavior, "pointClippingBehavior", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPointClippingBehavior(obj->pointClippingBehavior, "pointClippingBehavior", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkInputAttachmentAspectReference(VkInputAttachmentAspectReference obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj.subpass, "subpass", 1); + + print_uint32_t(obj.inputAttachmentIndex, "inputAttachmentIndex", 1); + + print_VkImageAspectFlags(obj.aspectMask, "aspectMask", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkInputAttachmentAspectReference(const VkInputAttachmentAspectReference * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj->subpass, "subpass", 1); + + print_uint32_t(obj->inputAttachmentIndex, "inputAttachmentIndex", 1); + + print_VkImageAspectFlags(obj->aspectMask, "aspectMask", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkRenderPassInputAttachmentAspectCreateInfo(VkRenderPassInputAttachmentAspectCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.aspectReferenceCount, "aspectReferenceCount", 1); + + PRINT_SPACE + _OUT << "\"pAspectReferences\": " << std::endl; + if (obj.pAspectReferences) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.aspectReferenceCount; i++) { + if (i+1 == obj.aspectReferenceCount) + print_VkInputAttachmentAspectReference(obj.pAspectReferences[i], "pAspectReferences", 0); + else + print_VkInputAttachmentAspectReference(obj.pAspectReferences[i], "pAspectReferences", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->aspectReferenceCount, "aspectReferenceCount", 1); + + PRINT_SPACE + _OUT << "\"pAspectReferences\": " << std::endl; + if (obj->pAspectReferences) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->aspectReferenceCount; i++) { + if (i+1 == obj->aspectReferenceCount) + print_VkInputAttachmentAspectReference(obj->pAspectReferences[i], "pAspectReferences", 0); + else + print_VkInputAttachmentAspectReference(obj->pAspectReferences[i], "pAspectReferences", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageViewUsageCreateInfo(VkImageViewUsageCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageUsageFlags(obj.usage, "usage", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageUsageFlags(obj->usage, "usage", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineTessellationDomainOriginStateCreateInfo(VkPipelineTessellationDomainOriginStateCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkTessellationDomainOrigin(obj.domainOrigin, "domainOrigin", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkTessellationDomainOrigin(obj->domainOrigin, "domainOrigin", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkRenderPassMultiviewCreateInfo(VkRenderPassMultiviewCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.subpassCount, "subpassCount", 1); + + PRINT_SPACE + _OUT << "\"pViewMasks\":" << std::endl; + PRINT_SPACE + if (obj.pViewMasks) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.subpassCount; i++) { + bool isCommaNeeded = (i+1) != obj.subpassCount; + print_uint32_t(obj.pViewMasks[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj.dependencyCount, "dependencyCount", 1); + + PRINT_SPACE + _OUT << "\"pViewOffsets\":" << std::endl; + PRINT_SPACE + if (obj.pViewOffsets) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.dependencyCount; i++) { + bool isCommaNeeded = (i+1) != obj.dependencyCount; + print_int32_t(obj.pViewOffsets[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj.correlationMaskCount, "correlationMaskCount", 1); + + PRINT_SPACE + _OUT << "\"pCorrelationMasks\":" << std::endl; + PRINT_SPACE + if (obj.pCorrelationMasks) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.correlationMaskCount; i++) { + bool isCommaNeeded = (i+1) != obj.correlationMaskCount; + print_uint32_t(obj.pCorrelationMasks[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->subpassCount, "subpassCount", 1); + + PRINT_SPACE + _OUT << "\"pViewMasks\":" << std::endl; + PRINT_SPACE + if (obj->pViewMasks) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->subpassCount; i++) { + bool isCommaNeeded = (i+1) != obj->subpassCount; + print_uint32_t(obj->pViewMasks[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj->dependencyCount, "dependencyCount", 1); + + PRINT_SPACE + _OUT << "\"pViewOffsets\":" << std::endl; + PRINT_SPACE + if (obj->pViewOffsets) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->dependencyCount; i++) { + bool isCommaNeeded = (i+1) != obj->dependencyCount; + print_int32_t(obj->pViewOffsets[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj->correlationMaskCount, "correlationMaskCount", 1); + + PRINT_SPACE + _OUT << "\"pCorrelationMasks\":" << std::endl; + PRINT_SPACE + if (obj->pCorrelationMasks) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->correlationMaskCount; i++) { + bool isCommaNeeded = (i+1) != obj->correlationMaskCount; + print_uint32_t(obj->pCorrelationMasks[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceMultiviewFeatures(VkPhysicalDeviceMultiviewFeatures obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.multiview, "multiview", 1); + + print_VkBool32(obj.multiviewGeometryShader, "multiviewGeometryShader", 1); + + print_VkBool32(obj.multiviewTessellationShader, "multiviewTessellationShader", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->multiview, "multiview", 1); + + print_VkBool32(obj->multiviewGeometryShader, "multiviewGeometryShader", 1); + + print_VkBool32(obj->multiviewTessellationShader, "multiviewTessellationShader", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceMultiviewProperties(VkPhysicalDeviceMultiviewProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.maxMultiviewViewCount, "maxMultiviewViewCount", 1); + + print_uint32_t(obj.maxMultiviewInstanceIndex, "maxMultiviewInstanceIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->maxMultiviewViewCount, "maxMultiviewViewCount", 1); + + print_uint32_t(obj->maxMultiviewInstanceIndex, "maxMultiviewInstanceIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceVariablePointersFeatures(VkPhysicalDeviceVariablePointersFeatures obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.variablePointersStorageBuffer, "variablePointersStorageBuffer", 1); + + print_VkBool32(obj.variablePointers, "variablePointers", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->variablePointersStorageBuffer, "variablePointersStorageBuffer", 1); + + print_VkBool32(obj->variablePointers, "variablePointers", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures; + +static void print_VkPhysicalDeviceProtectedMemoryFeatures(VkPhysicalDeviceProtectedMemoryFeatures obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.protectedMemory, "protectedMemory", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->protectedMemory, "protectedMemory", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceProtectedMemoryProperties(VkPhysicalDeviceProtectedMemoryProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.protectedNoFault, "protectedNoFault", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->protectedNoFault, "protectedNoFault", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDeviceQueueInfo2(VkDeviceQueueInfo2 obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceQueueCreateFlags(obj.flags, "flags", 1); + + print_uint32_t(obj.queueFamilyIndex, "queueFamilyIndex", 1); + + print_uint32_t(obj.queueIndex, "queueIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDeviceQueueInfo2(const VkDeviceQueueInfo2 * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceQueueCreateFlags(obj->flags, "flags", 1); + + print_uint32_t(obj->queueFamilyIndex, "queueFamilyIndex", 1); + + print_uint32_t(obj->queueIndex, "queueIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkProtectedSubmitInfo(VkProtectedSubmitInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.protectedSubmit, "protectedSubmit", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkProtectedSubmitInfo(const VkProtectedSubmitInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->protectedSubmit, "protectedSubmit", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSamplerYcbcrConversionCreateInfo(VkSamplerYcbcrConversionCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkFormat(obj.format, "format", 1); + + print_VkSamplerYcbcrModelConversion(obj.ycbcrModel, "ycbcrModel", 1); + + print_VkSamplerYcbcrRange(obj.ycbcrRange, "ycbcrRange", 1); + + PRINT_SPACE + _OUT << "\"components\": " << std::endl; + { + print_VkComponentMapping(obj.components, "components", 1); + } + + print_VkChromaLocation(obj.xChromaOffset, "xChromaOffset", 1); + + print_VkChromaLocation(obj.yChromaOffset, "yChromaOffset", 1); + + print_VkFilter(obj.chromaFilter, "chromaFilter", 1); + + print_VkBool32(obj.forceExplicitReconstruction, "forceExplicitReconstruction", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkFormat(obj->format, "format", 1); + + print_VkSamplerYcbcrModelConversion(obj->ycbcrModel, "ycbcrModel", 1); + + print_VkSamplerYcbcrRange(obj->ycbcrRange, "ycbcrRange", 1); + + PRINT_SPACE + _OUT << "\"components\": " << std::endl; + { + print_VkComponentMapping(obj->components, "components", 1); + } + + print_VkChromaLocation(obj->xChromaOffset, "xChromaOffset", 1); + + print_VkChromaLocation(obj->yChromaOffset, "yChromaOffset", 1); + + print_VkFilter(obj->chromaFilter, "chromaFilter", 1); + + print_VkBool32(obj->forceExplicitReconstruction, "forceExplicitReconstruction", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSamplerYcbcrConversionInfo(VkSamplerYcbcrConversionInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "conversion" << "\"" << " : " << "\"" << "\"" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "conversion" << "\"" << " : " << "\"" << "\"" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkBindImagePlaneMemoryInfo(VkBindImagePlaneMemoryInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageAspectFlagBits(obj.planeAspect, "planeAspect", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageAspectFlagBits(obj->planeAspect, "planeAspect", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImagePlaneMemoryRequirementsInfo(VkImagePlaneMemoryRequirementsInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageAspectFlagBits(obj.planeAspect, "planeAspect", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageAspectFlagBits(obj->planeAspect, "planeAspect", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceSamplerYcbcrConversionFeatures(VkPhysicalDeviceSamplerYcbcrConversionFeatures obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.samplerYcbcrConversion, "samplerYcbcrConversion", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->samplerYcbcrConversion, "samplerYcbcrConversion", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSamplerYcbcrConversionImageFormatProperties(VkSamplerYcbcrConversionImageFormatProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.combinedImageSamplerDescriptorCount, "combinedImageSamplerDescriptorCount", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->combinedImageSamplerDescriptorCount, "combinedImageSamplerDescriptorCount", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkExternalMemoryProperties(VkExternalMemoryProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkExternalMemoryFeatureFlags(obj.externalMemoryFeatures, "externalMemoryFeatures", 1); + + print_VkExternalMemoryHandleTypeFlags(obj.exportFromImportedHandleTypes, "exportFromImportedHandleTypes", 1); + + print_VkExternalMemoryHandleTypeFlags(obj.compatibleHandleTypes, "compatibleHandleTypes", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkExternalMemoryProperties(const VkExternalMemoryProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkExternalMemoryFeatureFlags(obj->externalMemoryFeatures, "externalMemoryFeatures", 1); + + print_VkExternalMemoryHandleTypeFlags(obj->exportFromImportedHandleTypes, "exportFromImportedHandleTypes", 1); + + print_VkExternalMemoryHandleTypeFlags(obj->compatibleHandleTypes, "compatibleHandleTypes", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceExternalImageFormatInfo(VkPhysicalDeviceExternalImageFormatInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalMemoryHandleTypeFlagBits(obj.handleType, "handleType", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalMemoryHandleTypeFlagBits(obj->handleType, "handleType", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkExternalImageFormatProperties(VkExternalImageFormatProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"externalMemoryProperties\": " << std::endl; + { + print_VkExternalMemoryProperties(obj.externalMemoryProperties, "externalMemoryProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkExternalImageFormatProperties(const VkExternalImageFormatProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"externalMemoryProperties\": " << std::endl; + { + print_VkExternalMemoryProperties(obj->externalMemoryProperties, "externalMemoryProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceExternalBufferInfo(VkPhysicalDeviceExternalBufferInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBufferCreateFlags(obj.flags, "flags", 1); + + print_VkBufferUsageFlags(obj.usage, "usage", 1); + + print_VkExternalMemoryHandleTypeFlagBits(obj.handleType, "handleType", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBufferCreateFlags(obj->flags, "flags", 1); + + print_VkBufferUsageFlags(obj->usage, "usage", 1); + + print_VkExternalMemoryHandleTypeFlagBits(obj->handleType, "handleType", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkExternalBufferProperties(VkExternalBufferProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"externalMemoryProperties\": " << std::endl; + { + print_VkExternalMemoryProperties(obj.externalMemoryProperties, "externalMemoryProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkExternalBufferProperties(const VkExternalBufferProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"externalMemoryProperties\": " << std::endl; + { + print_VkExternalMemoryProperties(obj->externalMemoryProperties, "externalMemoryProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceIDProperties(VkPhysicalDeviceIDProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"deviceUUID\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_UUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_UUID_SIZE; + print_uint8_t(obj.deviceUUID[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"driverUUID\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_UUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_UUID_SIZE; + print_uint8_t(obj.driverUUID[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"deviceLUID\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_LUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_LUID_SIZE; + print_uint8_t(obj.deviceLUID[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_uint32_t(obj.deviceNodeMask, "deviceNodeMask", 1); + + print_VkBool32(obj.deviceLUIDValid, "deviceLUIDValid", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"deviceUUID\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_UUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_UUID_SIZE; + print_uint8_t(obj->deviceUUID[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"driverUUID\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_UUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_UUID_SIZE; + print_uint8_t(obj->driverUUID[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"deviceLUID\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_LUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_LUID_SIZE; + print_uint8_t(obj->deviceLUID[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_uint32_t(obj->deviceNodeMask, "deviceNodeMask", 1); + + print_VkBool32(obj->deviceLUIDValid, "deviceLUIDValid", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkExternalMemoryImageCreateInfo(VkExternalMemoryImageCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalMemoryHandleTypeFlags(obj.handleTypes, "handleTypes", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalMemoryHandleTypeFlags(obj->handleTypes, "handleTypes", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkExternalMemoryBufferCreateInfo(VkExternalMemoryBufferCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalMemoryHandleTypeFlags(obj.handleTypes, "handleTypes", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalMemoryHandleTypeFlags(obj->handleTypes, "handleTypes", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkExportMemoryAllocateInfo(VkExportMemoryAllocateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalMemoryHandleTypeFlags(obj.handleTypes, "handleTypes", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalMemoryHandleTypeFlags(obj->handleTypes, "handleTypes", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceExternalFenceInfo(VkPhysicalDeviceExternalFenceInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalFenceHandleTypeFlagBits(obj.handleType, "handleType", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalFenceHandleTypeFlagBits(obj->handleType, "handleType", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkExternalFenceProperties(VkExternalFenceProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalFenceHandleTypeFlags(obj.exportFromImportedHandleTypes, "exportFromImportedHandleTypes", 1); + + print_VkExternalFenceHandleTypeFlags(obj.compatibleHandleTypes, "compatibleHandleTypes", 1); + + print_VkExternalFenceFeatureFlags(obj.externalFenceFeatures, "externalFenceFeatures", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkExternalFenceProperties(const VkExternalFenceProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalFenceHandleTypeFlags(obj->exportFromImportedHandleTypes, "exportFromImportedHandleTypes", 1); + + print_VkExternalFenceHandleTypeFlags(obj->compatibleHandleTypes, "compatibleHandleTypes", 1); + + print_VkExternalFenceFeatureFlags(obj->externalFenceFeatures, "externalFenceFeatures", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkExportFenceCreateInfo(VkExportFenceCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalFenceHandleTypeFlags(obj.handleTypes, "handleTypes", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkExportFenceCreateInfo(const VkExportFenceCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalFenceHandleTypeFlags(obj->handleTypes, "handleTypes", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkExportSemaphoreCreateInfo(VkExportSemaphoreCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalSemaphoreHandleTypeFlags(obj.handleTypes, "handleTypes", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalSemaphoreHandleTypeFlags(obj->handleTypes, "handleTypes", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceExternalSemaphoreInfo(VkPhysicalDeviceExternalSemaphoreInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalSemaphoreHandleTypeFlagBits(obj.handleType, "handleType", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalSemaphoreHandleTypeFlagBits(obj->handleType, "handleType", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkExternalSemaphoreProperties(VkExternalSemaphoreProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalSemaphoreHandleTypeFlags(obj.exportFromImportedHandleTypes, "exportFromImportedHandleTypes", 1); + + print_VkExternalSemaphoreHandleTypeFlags(obj.compatibleHandleTypes, "compatibleHandleTypes", 1); + + print_VkExternalSemaphoreFeatureFlags(obj.externalSemaphoreFeatures, "externalSemaphoreFeatures", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalSemaphoreHandleTypeFlags(obj->exportFromImportedHandleTypes, "exportFromImportedHandleTypes", 1); + + print_VkExternalSemaphoreHandleTypeFlags(obj->compatibleHandleTypes, "compatibleHandleTypes", 1); + + print_VkExternalSemaphoreFeatureFlags(obj->externalSemaphoreFeatures, "externalSemaphoreFeatures", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceMaintenance3Properties(VkPhysicalDeviceMaintenance3Properties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.maxPerSetDescriptors, "maxPerSetDescriptors", 1); + + print_VkDeviceSize(obj.maxMemoryAllocationSize, "maxMemoryAllocationSize", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->maxPerSetDescriptors, "maxPerSetDescriptors", 1); + + print_VkDeviceSize(obj->maxMemoryAllocationSize, "maxMemoryAllocationSize", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDescriptorSetLayoutSupport(VkDescriptorSetLayoutSupport obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.supported, "supported", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->supported, "supported", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceShaderDrawParametersFeatures(VkPhysicalDeviceShaderDrawParametersFeatures obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.shaderDrawParameters, "shaderDrawParameters", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->shaderDrawParameters, "shaderDrawParameters", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures; + +static std::map VkDriverId_map = { + std::make_pair(1, "VK_DRIVER_ID_AMD_PROPRIETARY"), + std::make_pair(2, "VK_DRIVER_ID_AMD_OPEN_SOURCE"), + std::make_pair(3, "VK_DRIVER_ID_MESA_RADV"), + std::make_pair(4, "VK_DRIVER_ID_NVIDIA_PROPRIETARY"), + std::make_pair(5, "VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS"), + std::make_pair(6, "VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA"), + std::make_pair(7, "VK_DRIVER_ID_IMAGINATION_PROPRIETARY"), + std::make_pair(8, "VK_DRIVER_ID_QUALCOMM_PROPRIETARY"), + std::make_pair(9, "VK_DRIVER_ID_ARM_PROPRIETARY"), + std::make_pair(10, "VK_DRIVER_ID_GOOGLE_SWIFTSHADER"), + std::make_pair(11, "VK_DRIVER_ID_GGP_PROPRIETARY"), + std::make_pair(12, "VK_DRIVER_ID_BROADCOM_PROPRIETARY"), + std::make_pair(13, "VK_DRIVER_ID_MESA_LLVMPIPE"), + std::make_pair(14, "VK_DRIVER_ID_MOLTENVK"), + std::make_pair(15, "VK_DRIVER_ID_COREAVI_PROPRIETARY"), + std::make_pair(16, "VK_DRIVER_ID_JUICE_PROPRIETARY"), + std::make_pair(17, "VK_DRIVER_ID_VERISILICON_PROPRIETARY"), + std::make_pair(18, "VK_DRIVER_ID_MESA_TURNIP"), + std::make_pair(19, "VK_DRIVER_ID_MESA_V3DV"), + std::make_pair(20, "VK_DRIVER_ID_MESA_PANVK"), + std::make_pair(21, "VK_DRIVER_ID_SAMSUNG_PROPRIETARY"), +}; +static void print_VkDriverId(VkDriverId obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDriverId_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDriverId_map[obj] << "\"" << std::endl; +} +static void print_VkDriverId(const VkDriverId * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDriverId_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDriverId_map[*obj] << "\"" << std::endl; +} + +static std::map VkShaderFloatControlsIndependence_map = { + std::make_pair(0, "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY"), + std::make_pair(1, "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL"), + std::make_pair(2, "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE"), +}; +static void print_VkShaderFloatControlsIndependence(VkShaderFloatControlsIndependence obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkShaderFloatControlsIndependence_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkShaderFloatControlsIndependence_map[obj] << "\"" << std::endl; +} +static void print_VkShaderFloatControlsIndependence(const VkShaderFloatControlsIndependence * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkShaderFloatControlsIndependence_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkShaderFloatControlsIndependence_map[*obj] << "\"" << std::endl; +} + +static std::map VkResolveModeFlagBits_map = { + std::make_pair(0, "VK_RESOLVE_MODE_NONE"), + std::make_pair(1ULL << 0, "VK_RESOLVE_MODE_SAMPLE_ZERO_BIT"), + std::make_pair(1ULL << 1, "VK_RESOLVE_MODE_AVERAGE_BIT"), + std::make_pair(1ULL << 2, "VK_RESOLVE_MODE_MIN_BIT"), + std::make_pair(1ULL << 3, "VK_RESOLVE_MODE_MAX_BIT"), +}; +static void print_VkResolveModeFlagBits(VkResolveModeFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkResolveModeFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkResolveModeFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkResolveModeFlagBits(const VkResolveModeFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkResolveModeFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkResolveModeFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkDescriptorBindingFlagBits_map = { + std::make_pair(1ULL << 0, "VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT"), + std::make_pair(1ULL << 1, "VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT"), + std::make_pair(1ULL << 2, "VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT"), + std::make_pair(1ULL << 3, "VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT"), + std::make_pair(1ULL << 4, "VK_DESCRIPTOR_BINDING_RESERVED_4_BIT_QCOM"), +}; +static void print_VkDescriptorBindingFlagBits(VkDescriptorBindingFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDescriptorBindingFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDescriptorBindingFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkDescriptorBindingFlagBits(const VkDescriptorBindingFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDescriptorBindingFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDescriptorBindingFlagBits_map[*obj] << "\"" << std::endl; +} + +static std::map VkSamplerReductionMode_map = { + std::make_pair(0, "VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE"), + std::make_pair(1, "VK_SAMPLER_REDUCTION_MODE_MIN"), + std::make_pair(2, "VK_SAMPLER_REDUCTION_MODE_MAX"), +}; +static void print_VkSamplerReductionMode(VkSamplerReductionMode obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSamplerReductionMode_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSamplerReductionMode_map[obj] << "\"" << std::endl; +} +static void print_VkSamplerReductionMode(const VkSamplerReductionMode * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSamplerReductionMode_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSamplerReductionMode_map[*obj] << "\"" << std::endl; +} + +static std::map VkSemaphoreType_map = { + std::make_pair(0, "VK_SEMAPHORE_TYPE_BINARY"), + std::make_pair(1, "VK_SEMAPHORE_TYPE_TIMELINE"), +}; +static void print_VkSemaphoreType(VkSemaphoreType obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSemaphoreType_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSemaphoreType_map[obj] << "\"" << std::endl; +} +static void print_VkSemaphoreType(const VkSemaphoreType * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSemaphoreType_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSemaphoreType_map[*obj] << "\"" << std::endl; +} + +static std::map VkSemaphoreWaitFlagBits_map = { + std::make_pair(1ULL << 0, "VK_SEMAPHORE_WAIT_ANY_BIT"), +}; +static void print_VkSemaphoreWaitFlagBits(VkSemaphoreWaitFlagBits obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSemaphoreWaitFlagBits_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSemaphoreWaitFlagBits_map[obj] << "\"" << std::endl; +} +static void print_VkSemaphoreWaitFlagBits(const VkSemaphoreWaitFlagBits * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSemaphoreWaitFlagBits_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSemaphoreWaitFlagBits_map[*obj] << "\"" << std::endl; +} + +static void print_VkResolveModeFlags(VkResolveModeFlags obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + const int max_bits = 64; // We don't expect the number to be larger. + std::bitset b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkResolveModeFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkResolveModeFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkDescriptorBindingFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkDescriptorBindingFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkSemaphoreWaitFlagBits_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkSemaphoreWaitFlagBits_map[1ULL<sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->storageBuffer16BitAccess, "storageBuffer16BitAccess", 1); + + print_VkBool32(obj->uniformAndStorageBuffer16BitAccess, "uniformAndStorageBuffer16BitAccess", 1); + + print_VkBool32(obj->storagePushConstant16, "storagePushConstant16", 1); + + print_VkBool32(obj->storageInputOutput16, "storageInputOutput16", 1); + + print_VkBool32(obj->multiview, "multiview", 1); + + print_VkBool32(obj->multiviewGeometryShader, "multiviewGeometryShader", 1); + + print_VkBool32(obj->multiviewTessellationShader, "multiviewTessellationShader", 1); + + print_VkBool32(obj->variablePointersStorageBuffer, "variablePointersStorageBuffer", 1); + + print_VkBool32(obj->variablePointers, "variablePointers", 1); + + print_VkBool32(obj->protectedMemory, "protectedMemory", 1); + + print_VkBool32(obj->samplerYcbcrConversion, "samplerYcbcrConversion", 1); + + print_VkBool32(obj->shaderDrawParameters, "shaderDrawParameters", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceVulkan11Properties(VkPhysicalDeviceVulkan11Properties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"deviceUUID\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_UUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_UUID_SIZE; + print_uint8_t(obj.deviceUUID[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"driverUUID\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_UUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_UUID_SIZE; + print_uint8_t(obj.driverUUID[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"deviceLUID\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_LUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_LUID_SIZE; + print_uint8_t(obj.deviceLUID[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_uint32_t(obj.deviceNodeMask, "deviceNodeMask", 1); + + print_VkBool32(obj.deviceLUIDValid, "deviceLUIDValid", 1); + + print_uint32_t(obj.subgroupSize, "subgroupSize", 1); + + print_VkShaderStageFlags(obj.subgroupSupportedStages, "subgroupSupportedStages", 1); + + print_VkSubgroupFeatureFlags(obj.subgroupSupportedOperations, "subgroupSupportedOperations", 1); + + print_VkBool32(obj.subgroupQuadOperationsInAllStages, "subgroupQuadOperationsInAllStages", 1); + + print_VkPointClippingBehavior(obj.pointClippingBehavior, "pointClippingBehavior", 1); + + print_uint32_t(obj.maxMultiviewViewCount, "maxMultiviewViewCount", 1); + + print_uint32_t(obj.maxMultiviewInstanceIndex, "maxMultiviewInstanceIndex", 1); + + print_VkBool32(obj.protectedNoFault, "protectedNoFault", 1); + + print_uint32_t(obj.maxPerSetDescriptors, "maxPerSetDescriptors", 1); + + print_VkDeviceSize(obj.maxMemoryAllocationSize, "maxMemoryAllocationSize", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"deviceUUID\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_UUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_UUID_SIZE; + print_uint8_t(obj->deviceUUID[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"driverUUID\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_UUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_UUID_SIZE; + print_uint8_t(obj->driverUUID[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"deviceLUID\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_LUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_LUID_SIZE; + print_uint8_t(obj->deviceLUID[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_uint32_t(obj->deviceNodeMask, "deviceNodeMask", 1); + + print_VkBool32(obj->deviceLUIDValid, "deviceLUIDValid", 1); + + print_uint32_t(obj->subgroupSize, "subgroupSize", 1); + + print_VkShaderStageFlags(obj->subgroupSupportedStages, "subgroupSupportedStages", 1); + + print_VkSubgroupFeatureFlags(obj->subgroupSupportedOperations, "subgroupSupportedOperations", 1); + + print_VkBool32(obj->subgroupQuadOperationsInAllStages, "subgroupQuadOperationsInAllStages", 1); + + print_VkPointClippingBehavior(obj->pointClippingBehavior, "pointClippingBehavior", 1); + + print_uint32_t(obj->maxMultiviewViewCount, "maxMultiviewViewCount", 1); + + print_uint32_t(obj->maxMultiviewInstanceIndex, "maxMultiviewInstanceIndex", 1); + + print_VkBool32(obj->protectedNoFault, "protectedNoFault", 1); + + print_uint32_t(obj->maxPerSetDescriptors, "maxPerSetDescriptors", 1); + + print_VkDeviceSize(obj->maxMemoryAllocationSize, "maxMemoryAllocationSize", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceVulkan12Features(VkPhysicalDeviceVulkan12Features obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.samplerMirrorClampToEdge, "samplerMirrorClampToEdge", 1); + + print_VkBool32(obj.drawIndirectCount, "drawIndirectCount", 1); + + print_VkBool32(obj.storageBuffer8BitAccess, "storageBuffer8BitAccess", 1); + + print_VkBool32(obj.uniformAndStorageBuffer8BitAccess, "uniformAndStorageBuffer8BitAccess", 1); + + print_VkBool32(obj.storagePushConstant8, "storagePushConstant8", 1); + + print_VkBool32(obj.shaderBufferInt64Atomics, "shaderBufferInt64Atomics", 1); + + print_VkBool32(obj.shaderSharedInt64Atomics, "shaderSharedInt64Atomics", 1); + + print_VkBool32(obj.shaderFloat16, "shaderFloat16", 1); + + print_VkBool32(obj.shaderInt8, "shaderInt8", 1); + + print_VkBool32(obj.descriptorIndexing, "descriptorIndexing", 1); + + print_VkBool32(obj.shaderInputAttachmentArrayDynamicIndexing, "shaderInputAttachmentArrayDynamicIndexing", 1); + + print_VkBool32(obj.shaderUniformTexelBufferArrayDynamicIndexing, "shaderUniformTexelBufferArrayDynamicIndexing", 1); + + print_VkBool32(obj.shaderStorageTexelBufferArrayDynamicIndexing, "shaderStorageTexelBufferArrayDynamicIndexing", 1); + + print_VkBool32(obj.shaderUniformBufferArrayNonUniformIndexing, "shaderUniformBufferArrayNonUniformIndexing", 1); + + print_VkBool32(obj.shaderSampledImageArrayNonUniformIndexing, "shaderSampledImageArrayNonUniformIndexing", 1); + + print_VkBool32(obj.shaderStorageBufferArrayNonUniformIndexing, "shaderStorageBufferArrayNonUniformIndexing", 1); + + print_VkBool32(obj.shaderStorageImageArrayNonUniformIndexing, "shaderStorageImageArrayNonUniformIndexing", 1); + + print_VkBool32(obj.shaderInputAttachmentArrayNonUniformIndexing, "shaderInputAttachmentArrayNonUniformIndexing", 1); + + print_VkBool32(obj.shaderUniformTexelBufferArrayNonUniformIndexing, "shaderUniformTexelBufferArrayNonUniformIndexing", 1); + + print_VkBool32(obj.shaderStorageTexelBufferArrayNonUniformIndexing, "shaderStorageTexelBufferArrayNonUniformIndexing", 1); + + print_VkBool32(obj.descriptorBindingUniformBufferUpdateAfterBind, "descriptorBindingUniformBufferUpdateAfterBind", 1); + + print_VkBool32(obj.descriptorBindingSampledImageUpdateAfterBind, "descriptorBindingSampledImageUpdateAfterBind", 1); + + print_VkBool32(obj.descriptorBindingStorageImageUpdateAfterBind, "descriptorBindingStorageImageUpdateAfterBind", 1); + + print_VkBool32(obj.descriptorBindingStorageBufferUpdateAfterBind, "descriptorBindingStorageBufferUpdateAfterBind", 1); + + print_VkBool32(obj.descriptorBindingUniformTexelBufferUpdateAfterBind, "descriptorBindingUniformTexelBufferUpdateAfterBind", 1); + + print_VkBool32(obj.descriptorBindingStorageTexelBufferUpdateAfterBind, "descriptorBindingStorageTexelBufferUpdateAfterBind", 1); + + print_VkBool32(obj.descriptorBindingUpdateUnusedWhilePending, "descriptorBindingUpdateUnusedWhilePending", 1); + + print_VkBool32(obj.descriptorBindingPartiallyBound, "descriptorBindingPartiallyBound", 1); + + print_VkBool32(obj.descriptorBindingVariableDescriptorCount, "descriptorBindingVariableDescriptorCount", 1); + + print_VkBool32(obj.runtimeDescriptorArray, "runtimeDescriptorArray", 1); + + print_VkBool32(obj.samplerFilterMinmax, "samplerFilterMinmax", 1); + + print_VkBool32(obj.scalarBlockLayout, "scalarBlockLayout", 1); + + print_VkBool32(obj.imagelessFramebuffer, "imagelessFramebuffer", 1); + + print_VkBool32(obj.uniformBufferStandardLayout, "uniformBufferStandardLayout", 1); + + print_VkBool32(obj.shaderSubgroupExtendedTypes, "shaderSubgroupExtendedTypes", 1); + + print_VkBool32(obj.separateDepthStencilLayouts, "separateDepthStencilLayouts", 1); + + print_VkBool32(obj.hostQueryReset, "hostQueryReset", 1); + + print_VkBool32(obj.timelineSemaphore, "timelineSemaphore", 1); + + print_VkBool32(obj.bufferDeviceAddress, "bufferDeviceAddress", 1); + + print_VkBool32(obj.bufferDeviceAddressCaptureReplay, "bufferDeviceAddressCaptureReplay", 1); + + print_VkBool32(obj.bufferDeviceAddressMultiDevice, "bufferDeviceAddressMultiDevice", 1); + + print_VkBool32(obj.vulkanMemoryModel, "vulkanMemoryModel", 1); + + print_VkBool32(obj.vulkanMemoryModelDeviceScope, "vulkanMemoryModelDeviceScope", 1); + + print_VkBool32(obj.vulkanMemoryModelAvailabilityVisibilityChains, "vulkanMemoryModelAvailabilityVisibilityChains", 1); + + print_VkBool32(obj.shaderOutputViewportIndex, "shaderOutputViewportIndex", 1); + + print_VkBool32(obj.shaderOutputLayer, "shaderOutputLayer", 1); + + print_VkBool32(obj.subgroupBroadcastDynamicId, "subgroupBroadcastDynamicId", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->samplerMirrorClampToEdge, "samplerMirrorClampToEdge", 1); + + print_VkBool32(obj->drawIndirectCount, "drawIndirectCount", 1); + + print_VkBool32(obj->storageBuffer8BitAccess, "storageBuffer8BitAccess", 1); + + print_VkBool32(obj->uniformAndStorageBuffer8BitAccess, "uniformAndStorageBuffer8BitAccess", 1); + + print_VkBool32(obj->storagePushConstant8, "storagePushConstant8", 1); + + print_VkBool32(obj->shaderBufferInt64Atomics, "shaderBufferInt64Atomics", 1); + + print_VkBool32(obj->shaderSharedInt64Atomics, "shaderSharedInt64Atomics", 1); + + print_VkBool32(obj->shaderFloat16, "shaderFloat16", 1); + + print_VkBool32(obj->shaderInt8, "shaderInt8", 1); + + print_VkBool32(obj->descriptorIndexing, "descriptorIndexing", 1); + + print_VkBool32(obj->shaderInputAttachmentArrayDynamicIndexing, "shaderInputAttachmentArrayDynamicIndexing", 1); + + print_VkBool32(obj->shaderUniformTexelBufferArrayDynamicIndexing, "shaderUniformTexelBufferArrayDynamicIndexing", 1); + + print_VkBool32(obj->shaderStorageTexelBufferArrayDynamicIndexing, "shaderStorageTexelBufferArrayDynamicIndexing", 1); + + print_VkBool32(obj->shaderUniformBufferArrayNonUniformIndexing, "shaderUniformBufferArrayNonUniformIndexing", 1); + + print_VkBool32(obj->shaderSampledImageArrayNonUniformIndexing, "shaderSampledImageArrayNonUniformIndexing", 1); + + print_VkBool32(obj->shaderStorageBufferArrayNonUniformIndexing, "shaderStorageBufferArrayNonUniformIndexing", 1); + + print_VkBool32(obj->shaderStorageImageArrayNonUniformIndexing, "shaderStorageImageArrayNonUniformIndexing", 1); + + print_VkBool32(obj->shaderInputAttachmentArrayNonUniformIndexing, "shaderInputAttachmentArrayNonUniformIndexing", 1); + + print_VkBool32(obj->shaderUniformTexelBufferArrayNonUniformIndexing, "shaderUniformTexelBufferArrayNonUniformIndexing", 1); + + print_VkBool32(obj->shaderStorageTexelBufferArrayNonUniformIndexing, "shaderStorageTexelBufferArrayNonUniformIndexing", 1); + + print_VkBool32(obj->descriptorBindingUniformBufferUpdateAfterBind, "descriptorBindingUniformBufferUpdateAfterBind", 1); + + print_VkBool32(obj->descriptorBindingSampledImageUpdateAfterBind, "descriptorBindingSampledImageUpdateAfterBind", 1); + + print_VkBool32(obj->descriptorBindingStorageImageUpdateAfterBind, "descriptorBindingStorageImageUpdateAfterBind", 1); + + print_VkBool32(obj->descriptorBindingStorageBufferUpdateAfterBind, "descriptorBindingStorageBufferUpdateAfterBind", 1); + + print_VkBool32(obj->descriptorBindingUniformTexelBufferUpdateAfterBind, "descriptorBindingUniformTexelBufferUpdateAfterBind", 1); + + print_VkBool32(obj->descriptorBindingStorageTexelBufferUpdateAfterBind, "descriptorBindingStorageTexelBufferUpdateAfterBind", 1); + + print_VkBool32(obj->descriptorBindingUpdateUnusedWhilePending, "descriptorBindingUpdateUnusedWhilePending", 1); + + print_VkBool32(obj->descriptorBindingPartiallyBound, "descriptorBindingPartiallyBound", 1); + + print_VkBool32(obj->descriptorBindingVariableDescriptorCount, "descriptorBindingVariableDescriptorCount", 1); + + print_VkBool32(obj->runtimeDescriptorArray, "runtimeDescriptorArray", 1); + + print_VkBool32(obj->samplerFilterMinmax, "samplerFilterMinmax", 1); + + print_VkBool32(obj->scalarBlockLayout, "scalarBlockLayout", 1); + + print_VkBool32(obj->imagelessFramebuffer, "imagelessFramebuffer", 1); + + print_VkBool32(obj->uniformBufferStandardLayout, "uniformBufferStandardLayout", 1); + + print_VkBool32(obj->shaderSubgroupExtendedTypes, "shaderSubgroupExtendedTypes", 1); + + print_VkBool32(obj->separateDepthStencilLayouts, "separateDepthStencilLayouts", 1); + + print_VkBool32(obj->hostQueryReset, "hostQueryReset", 1); + + print_VkBool32(obj->timelineSemaphore, "timelineSemaphore", 1); + + print_VkBool32(obj->bufferDeviceAddress, "bufferDeviceAddress", 1); + + print_VkBool32(obj->bufferDeviceAddressCaptureReplay, "bufferDeviceAddressCaptureReplay", 1); + + print_VkBool32(obj->bufferDeviceAddressMultiDevice, "bufferDeviceAddressMultiDevice", 1); + + print_VkBool32(obj->vulkanMemoryModel, "vulkanMemoryModel", 1); + + print_VkBool32(obj->vulkanMemoryModelDeviceScope, "vulkanMemoryModelDeviceScope", 1); + + print_VkBool32(obj->vulkanMemoryModelAvailabilityVisibilityChains, "vulkanMemoryModelAvailabilityVisibilityChains", 1); + + print_VkBool32(obj->shaderOutputViewportIndex, "shaderOutputViewportIndex", 1); + + print_VkBool32(obj->shaderOutputLayer, "shaderOutputLayer", 1); + + print_VkBool32(obj->subgroupBroadcastDynamicId, "subgroupBroadcastDynamicId", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkConformanceVersion(VkConformanceVersion obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint8_t(obj.major, "major", 1); + + print_uint8_t(obj.minor, "minor", 1); + + print_uint8_t(obj.subminor, "subminor", 1); + + print_uint8_t(obj.patch, "patch", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkConformanceVersion(const VkConformanceVersion * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint8_t(obj->major, "major", 1); + + print_uint8_t(obj->minor, "minor", 1); + + print_uint8_t(obj->subminor, "subminor", 1); + + print_uint8_t(obj->patch, "patch", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceVulkan12Properties(VkPhysicalDeviceVulkan12Properties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDriverId(obj.driverID, "driverID", 1); + + PRINT_SPACE + _OUT << "\"driverName\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_DRIVER_NAME_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_DRIVER_NAME_SIZE; + print_char(obj.driverName[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"driverInfo\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_DRIVER_INFO_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_DRIVER_INFO_SIZE; + print_char(obj.driverInfo[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"conformanceVersion\": " << std::endl; + { + print_VkConformanceVersion(obj.conformanceVersion, "conformanceVersion", 1); + } + + print_VkShaderFloatControlsIndependence(obj.denormBehaviorIndependence, "denormBehaviorIndependence", 1); + + print_VkShaderFloatControlsIndependence(obj.roundingModeIndependence, "roundingModeIndependence", 1); + + print_VkBool32(obj.shaderSignedZeroInfNanPreserveFloat16, "shaderSignedZeroInfNanPreserveFloat16", 1); + + print_VkBool32(obj.shaderSignedZeroInfNanPreserveFloat32, "shaderSignedZeroInfNanPreserveFloat32", 1); + + print_VkBool32(obj.shaderSignedZeroInfNanPreserveFloat64, "shaderSignedZeroInfNanPreserveFloat64", 1); + + print_VkBool32(obj.shaderDenormPreserveFloat16, "shaderDenormPreserveFloat16", 1); + + print_VkBool32(obj.shaderDenormPreserveFloat32, "shaderDenormPreserveFloat32", 1); + + print_VkBool32(obj.shaderDenormPreserveFloat64, "shaderDenormPreserveFloat64", 1); + + print_VkBool32(obj.shaderDenormFlushToZeroFloat16, "shaderDenormFlushToZeroFloat16", 1); + + print_VkBool32(obj.shaderDenormFlushToZeroFloat32, "shaderDenormFlushToZeroFloat32", 1); + + print_VkBool32(obj.shaderDenormFlushToZeroFloat64, "shaderDenormFlushToZeroFloat64", 1); + + print_VkBool32(obj.shaderRoundingModeRTEFloat16, "shaderRoundingModeRTEFloat16", 1); + + print_VkBool32(obj.shaderRoundingModeRTEFloat32, "shaderRoundingModeRTEFloat32", 1); + + print_VkBool32(obj.shaderRoundingModeRTEFloat64, "shaderRoundingModeRTEFloat64", 1); + + print_VkBool32(obj.shaderRoundingModeRTZFloat16, "shaderRoundingModeRTZFloat16", 1); + + print_VkBool32(obj.shaderRoundingModeRTZFloat32, "shaderRoundingModeRTZFloat32", 1); + + print_VkBool32(obj.shaderRoundingModeRTZFloat64, "shaderRoundingModeRTZFloat64", 1); + + print_uint32_t(obj.maxUpdateAfterBindDescriptorsInAllPools, "maxUpdateAfterBindDescriptorsInAllPools", 1); + + print_VkBool32(obj.shaderUniformBufferArrayNonUniformIndexingNative, "shaderUniformBufferArrayNonUniformIndexingNative", 1); + + print_VkBool32(obj.shaderSampledImageArrayNonUniformIndexingNative, "shaderSampledImageArrayNonUniformIndexingNative", 1); + + print_VkBool32(obj.shaderStorageBufferArrayNonUniformIndexingNative, "shaderStorageBufferArrayNonUniformIndexingNative", 1); + + print_VkBool32(obj.shaderStorageImageArrayNonUniformIndexingNative, "shaderStorageImageArrayNonUniformIndexingNative", 1); + + print_VkBool32(obj.shaderInputAttachmentArrayNonUniformIndexingNative, "shaderInputAttachmentArrayNonUniformIndexingNative", 1); + + print_VkBool32(obj.robustBufferAccessUpdateAfterBind, "robustBufferAccessUpdateAfterBind", 1); + + print_VkBool32(obj.quadDivergentImplicitLod, "quadDivergentImplicitLod", 1); + + print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindSamplers, "maxPerStageDescriptorUpdateAfterBindSamplers", 1); + + print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindUniformBuffers, "maxPerStageDescriptorUpdateAfterBindUniformBuffers", 1); + + print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindStorageBuffers, "maxPerStageDescriptorUpdateAfterBindStorageBuffers", 1); + + print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindSampledImages, "maxPerStageDescriptorUpdateAfterBindSampledImages", 1); + + print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindStorageImages, "maxPerStageDescriptorUpdateAfterBindStorageImages", 1); + + print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindInputAttachments, "maxPerStageDescriptorUpdateAfterBindInputAttachments", 1); + + print_uint32_t(obj.maxPerStageUpdateAfterBindResources, "maxPerStageUpdateAfterBindResources", 1); + + print_uint32_t(obj.maxDescriptorSetUpdateAfterBindSamplers, "maxDescriptorSetUpdateAfterBindSamplers", 1); + + print_uint32_t(obj.maxDescriptorSetUpdateAfterBindUniformBuffers, "maxDescriptorSetUpdateAfterBindUniformBuffers", 1); + + print_uint32_t(obj.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", 1); + + print_uint32_t(obj.maxDescriptorSetUpdateAfterBindStorageBuffers, "maxDescriptorSetUpdateAfterBindStorageBuffers", 1); + + print_uint32_t(obj.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", 1); + + print_uint32_t(obj.maxDescriptorSetUpdateAfterBindSampledImages, "maxDescriptorSetUpdateAfterBindSampledImages", 1); + + print_uint32_t(obj.maxDescriptorSetUpdateAfterBindStorageImages, "maxDescriptorSetUpdateAfterBindStorageImages", 1); + + print_uint32_t(obj.maxDescriptorSetUpdateAfterBindInputAttachments, "maxDescriptorSetUpdateAfterBindInputAttachments", 1); + + print_VkResolveModeFlags(obj.supportedDepthResolveModes, "supportedDepthResolveModes", 1); + + print_VkResolveModeFlags(obj.supportedStencilResolveModes, "supportedStencilResolveModes", 1); + + print_VkBool32(obj.independentResolveNone, "independentResolveNone", 1); + + print_VkBool32(obj.independentResolve, "independentResolve", 1); + + print_VkBool32(obj.filterMinmaxSingleComponentFormats, "filterMinmaxSingleComponentFormats", 1); + + print_VkBool32(obj.filterMinmaxImageComponentMapping, "filterMinmaxImageComponentMapping", 1); + + print_uint64_t(obj.maxTimelineSemaphoreValueDifference, "maxTimelineSemaphoreValueDifference", 1); + + print_VkSampleCountFlags(obj.framebufferIntegerColorSampleCounts, "framebufferIntegerColorSampleCounts", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDriverId(obj->driverID, "driverID", 1); + + PRINT_SPACE + _OUT << "\"driverName\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_DRIVER_NAME_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_DRIVER_NAME_SIZE; + print_char(obj->driverName[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"driverInfo\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_DRIVER_INFO_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_DRIVER_INFO_SIZE; + print_char(obj->driverInfo[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"conformanceVersion\": " << std::endl; + { + print_VkConformanceVersion(obj->conformanceVersion, "conformanceVersion", 1); + } + + print_VkShaderFloatControlsIndependence(obj->denormBehaviorIndependence, "denormBehaviorIndependence", 1); + + print_VkShaderFloatControlsIndependence(obj->roundingModeIndependence, "roundingModeIndependence", 1); + + print_VkBool32(obj->shaderSignedZeroInfNanPreserveFloat16, "shaderSignedZeroInfNanPreserveFloat16", 1); + + print_VkBool32(obj->shaderSignedZeroInfNanPreserveFloat32, "shaderSignedZeroInfNanPreserveFloat32", 1); + + print_VkBool32(obj->shaderSignedZeroInfNanPreserveFloat64, "shaderSignedZeroInfNanPreserveFloat64", 1); + + print_VkBool32(obj->shaderDenormPreserveFloat16, "shaderDenormPreserveFloat16", 1); + + print_VkBool32(obj->shaderDenormPreserveFloat32, "shaderDenormPreserveFloat32", 1); + + print_VkBool32(obj->shaderDenormPreserveFloat64, "shaderDenormPreserveFloat64", 1); + + print_VkBool32(obj->shaderDenormFlushToZeroFloat16, "shaderDenormFlushToZeroFloat16", 1); + + print_VkBool32(obj->shaderDenormFlushToZeroFloat32, "shaderDenormFlushToZeroFloat32", 1); + + print_VkBool32(obj->shaderDenormFlushToZeroFloat64, "shaderDenormFlushToZeroFloat64", 1); + + print_VkBool32(obj->shaderRoundingModeRTEFloat16, "shaderRoundingModeRTEFloat16", 1); + + print_VkBool32(obj->shaderRoundingModeRTEFloat32, "shaderRoundingModeRTEFloat32", 1); + + print_VkBool32(obj->shaderRoundingModeRTEFloat64, "shaderRoundingModeRTEFloat64", 1); + + print_VkBool32(obj->shaderRoundingModeRTZFloat16, "shaderRoundingModeRTZFloat16", 1); + + print_VkBool32(obj->shaderRoundingModeRTZFloat32, "shaderRoundingModeRTZFloat32", 1); + + print_VkBool32(obj->shaderRoundingModeRTZFloat64, "shaderRoundingModeRTZFloat64", 1); + + print_uint32_t(obj->maxUpdateAfterBindDescriptorsInAllPools, "maxUpdateAfterBindDescriptorsInAllPools", 1); + + print_VkBool32(obj->shaderUniformBufferArrayNonUniformIndexingNative, "shaderUniformBufferArrayNonUniformIndexingNative", 1); + + print_VkBool32(obj->shaderSampledImageArrayNonUniformIndexingNative, "shaderSampledImageArrayNonUniformIndexingNative", 1); + + print_VkBool32(obj->shaderStorageBufferArrayNonUniformIndexingNative, "shaderStorageBufferArrayNonUniformIndexingNative", 1); + + print_VkBool32(obj->shaderStorageImageArrayNonUniformIndexingNative, "shaderStorageImageArrayNonUniformIndexingNative", 1); + + print_VkBool32(obj->shaderInputAttachmentArrayNonUniformIndexingNative, "shaderInputAttachmentArrayNonUniformIndexingNative", 1); + + print_VkBool32(obj->robustBufferAccessUpdateAfterBind, "robustBufferAccessUpdateAfterBind", 1); + + print_VkBool32(obj->quadDivergentImplicitLod, "quadDivergentImplicitLod", 1); + + print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindSamplers, "maxPerStageDescriptorUpdateAfterBindSamplers", 1); + + print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindUniformBuffers, "maxPerStageDescriptorUpdateAfterBindUniformBuffers", 1); + + print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindStorageBuffers, "maxPerStageDescriptorUpdateAfterBindStorageBuffers", 1); + + print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindSampledImages, "maxPerStageDescriptorUpdateAfterBindSampledImages", 1); + + print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindStorageImages, "maxPerStageDescriptorUpdateAfterBindStorageImages", 1); + + print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindInputAttachments, "maxPerStageDescriptorUpdateAfterBindInputAttachments", 1); + + print_uint32_t(obj->maxPerStageUpdateAfterBindResources, "maxPerStageUpdateAfterBindResources", 1); + + print_uint32_t(obj->maxDescriptorSetUpdateAfterBindSamplers, "maxDescriptorSetUpdateAfterBindSamplers", 1); + + print_uint32_t(obj->maxDescriptorSetUpdateAfterBindUniformBuffers, "maxDescriptorSetUpdateAfterBindUniformBuffers", 1); + + print_uint32_t(obj->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", 1); + + print_uint32_t(obj->maxDescriptorSetUpdateAfterBindStorageBuffers, "maxDescriptorSetUpdateAfterBindStorageBuffers", 1); + + print_uint32_t(obj->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", 1); + + print_uint32_t(obj->maxDescriptorSetUpdateAfterBindSampledImages, "maxDescriptorSetUpdateAfterBindSampledImages", 1); + + print_uint32_t(obj->maxDescriptorSetUpdateAfterBindStorageImages, "maxDescriptorSetUpdateAfterBindStorageImages", 1); + + print_uint32_t(obj->maxDescriptorSetUpdateAfterBindInputAttachments, "maxDescriptorSetUpdateAfterBindInputAttachments", 1); + + print_VkResolveModeFlags(obj->supportedDepthResolveModes, "supportedDepthResolveModes", 1); + + print_VkResolveModeFlags(obj->supportedStencilResolveModes, "supportedStencilResolveModes", 1); + + print_VkBool32(obj->independentResolveNone, "independentResolveNone", 1); + + print_VkBool32(obj->independentResolve, "independentResolve", 1); + + print_VkBool32(obj->filterMinmaxSingleComponentFormats, "filterMinmaxSingleComponentFormats", 1); + + print_VkBool32(obj->filterMinmaxImageComponentMapping, "filterMinmaxImageComponentMapping", 1); + + print_uint64_t(obj->maxTimelineSemaphoreValueDifference, "maxTimelineSemaphoreValueDifference", 1); + + print_VkSampleCountFlags(obj->framebufferIntegerColorSampleCounts, "framebufferIntegerColorSampleCounts", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageFormatListCreateInfo(VkImageFormatListCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.viewFormatCount, "viewFormatCount", 1); + + PRINT_SPACE + _OUT << "\"pViewFormats\":" << std::endl; + PRINT_SPACE + if (obj.pViewFormats) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.viewFormatCount; i++) { + bool isCommaNeeded = (i+1) != obj.viewFormatCount; + print_VkFormat(obj.pViewFormats[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->viewFormatCount, "viewFormatCount", 1); + + PRINT_SPACE + _OUT << "\"pViewFormats\":" << std::endl; + PRINT_SPACE + if (obj->pViewFormats) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->viewFormatCount; i++) { + bool isCommaNeeded = (i+1) != obj->viewFormatCount; + print_VkFormat(obj->pViewFormats[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkAttachmentDescription2(VkAttachmentDescription2 obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkAttachmentDescriptionFlags(obj.flags, "flags", 1); + + print_VkFormat(obj.format, "format", 1); + + print_VkSampleCountFlagBits(obj.samples, "samples", 1); + + print_VkAttachmentLoadOp(obj.loadOp, "loadOp", 1); + + print_VkAttachmentStoreOp(obj.storeOp, "storeOp", 1); + + print_VkAttachmentLoadOp(obj.stencilLoadOp, "stencilLoadOp", 1); + + print_VkAttachmentStoreOp(obj.stencilStoreOp, "stencilStoreOp", 1); + + print_VkImageLayout(obj.initialLayout, "initialLayout", 1); + + print_VkImageLayout(obj.finalLayout, "finalLayout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkAttachmentDescription2(const VkAttachmentDescription2 * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkAttachmentDescriptionFlags(obj->flags, "flags", 1); + + print_VkFormat(obj->format, "format", 1); + + print_VkSampleCountFlagBits(obj->samples, "samples", 1); + + print_VkAttachmentLoadOp(obj->loadOp, "loadOp", 1); + + print_VkAttachmentStoreOp(obj->storeOp, "storeOp", 1); + + print_VkAttachmentLoadOp(obj->stencilLoadOp, "stencilLoadOp", 1); + + print_VkAttachmentStoreOp(obj->stencilStoreOp, "stencilStoreOp", 1); + + print_VkImageLayout(obj->initialLayout, "initialLayout", 1); + + print_VkImageLayout(obj->finalLayout, "finalLayout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkAttachmentReference2(VkAttachmentReference2 obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.attachment, "attachment", 1); + + print_VkImageLayout(obj.layout, "layout", 1); + + print_VkImageAspectFlags(obj.aspectMask, "aspectMask", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkAttachmentReference2(const VkAttachmentReference2 * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->attachment, "attachment", 1); + + print_VkImageLayout(obj->layout, "layout", 1); + + print_VkImageAspectFlags(obj->aspectMask, "aspectMask", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSubpassDescription2(VkSubpassDescription2 obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSubpassDescriptionFlags(obj.flags, "flags", 1); + + print_VkPipelineBindPoint(obj.pipelineBindPoint, "pipelineBindPoint", 1); + + print_uint32_t(obj.viewMask, "viewMask", 1); + + print_uint32_t(obj.inputAttachmentCount, "inputAttachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pInputAttachments\": " << std::endl; + if (obj.pInputAttachments) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.inputAttachmentCount; i++) { + if (i+1 == obj.inputAttachmentCount) + print_VkAttachmentReference2(obj.pInputAttachments[i], "pInputAttachments", 0); + else + print_VkAttachmentReference2(obj.pInputAttachments[i], "pInputAttachments", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.colorAttachmentCount, "colorAttachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pColorAttachments\": " << std::endl; + if (obj.pColorAttachments) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.colorAttachmentCount; i++) { + if (i+1 == obj.colorAttachmentCount) + print_VkAttachmentReference2(obj.pColorAttachments[i], "pColorAttachments", 0); + else + print_VkAttachmentReference2(obj.pColorAttachments[i], "pColorAttachments", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pResolveAttachments\": " << std::endl; + if (obj.pResolveAttachments) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.colorAttachmentCount; i++) { + if (i+1 == obj.colorAttachmentCount) + print_VkAttachmentReference2(obj.pResolveAttachments[i], "pResolveAttachments", 0); + else + print_VkAttachmentReference2(obj.pResolveAttachments[i], "pResolveAttachments", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pDepthStencilAttachment\": " << std::endl; + if (obj.pDepthStencilAttachment) { + print_VkAttachmentReference2(obj.pDepthStencilAttachment, "pDepthStencilAttachment", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.preserveAttachmentCount, "preserveAttachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pPreserveAttachments\":" << std::endl; + PRINT_SPACE + if (obj.pPreserveAttachments) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.preserveAttachmentCount; i++) { + bool isCommaNeeded = (i+1) != obj.preserveAttachmentCount; + print_uint32_t(obj.pPreserveAttachments[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSubpassDescription2(const VkSubpassDescription2 * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSubpassDescriptionFlags(obj->flags, "flags", 1); + + print_VkPipelineBindPoint(obj->pipelineBindPoint, "pipelineBindPoint", 1); + + print_uint32_t(obj->viewMask, "viewMask", 1); + + print_uint32_t(obj->inputAttachmentCount, "inputAttachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pInputAttachments\": " << std::endl; + if (obj->pInputAttachments) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->inputAttachmentCount; i++) { + if (i+1 == obj->inputAttachmentCount) + print_VkAttachmentReference2(obj->pInputAttachments[i], "pInputAttachments", 0); + else + print_VkAttachmentReference2(obj->pInputAttachments[i], "pInputAttachments", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->colorAttachmentCount, "colorAttachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pColorAttachments\": " << std::endl; + if (obj->pColorAttachments) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->colorAttachmentCount; i++) { + if (i+1 == obj->colorAttachmentCount) + print_VkAttachmentReference2(obj->pColorAttachments[i], "pColorAttachments", 0); + else + print_VkAttachmentReference2(obj->pColorAttachments[i], "pColorAttachments", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pResolveAttachments\": " << std::endl; + if (obj->pResolveAttachments) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->colorAttachmentCount; i++) { + if (i+1 == obj->colorAttachmentCount) + print_VkAttachmentReference2(obj->pResolveAttachments[i], "pResolveAttachments", 0); + else + print_VkAttachmentReference2(obj->pResolveAttachments[i], "pResolveAttachments", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pDepthStencilAttachment\": " << std::endl; + if (obj->pDepthStencilAttachment) { + print_VkAttachmentReference2(obj->pDepthStencilAttachment, "pDepthStencilAttachment", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->preserveAttachmentCount, "preserveAttachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pPreserveAttachments\":" << std::endl; + PRINT_SPACE + if (obj->pPreserveAttachments) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->preserveAttachmentCount; i++) { + bool isCommaNeeded = (i+1) != obj->preserveAttachmentCount; + print_uint32_t(obj->pPreserveAttachments[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSubpassDependency2(VkSubpassDependency2 obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.srcSubpass, "srcSubpass", 1); + + print_uint32_t(obj.dstSubpass, "dstSubpass", 1); + + print_VkPipelineStageFlags(obj.srcStageMask, "srcStageMask", 1); + + print_VkPipelineStageFlags(obj.dstStageMask, "dstStageMask", 1); + + print_VkAccessFlags(obj.srcAccessMask, "srcAccessMask", 1); + + print_VkAccessFlags(obj.dstAccessMask, "dstAccessMask", 1); + + print_VkDependencyFlags(obj.dependencyFlags, "dependencyFlags", 1); + + print_int32_t(obj.viewOffset, "viewOffset", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSubpassDependency2(const VkSubpassDependency2 * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->srcSubpass, "srcSubpass", 1); + + print_uint32_t(obj->dstSubpass, "dstSubpass", 1); + + print_VkPipelineStageFlags(obj->srcStageMask, "srcStageMask", 1); + + print_VkPipelineStageFlags(obj->dstStageMask, "dstStageMask", 1); + + print_VkAccessFlags(obj->srcAccessMask, "srcAccessMask", 1); + + print_VkAccessFlags(obj->dstAccessMask, "dstAccessMask", 1); + + print_VkDependencyFlags(obj->dependencyFlags, "dependencyFlags", 1); + + print_int32_t(obj->viewOffset, "viewOffset", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkRenderPassCreateInfo2(VkRenderPassCreateInfo2 obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkRenderPassCreateFlags(obj.flags, "flags", 1); + + print_uint32_t(obj.attachmentCount, "attachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pAttachments\": " << std::endl; + if (obj.pAttachments) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.attachmentCount; i++) { + if (i+1 == obj.attachmentCount) + print_VkAttachmentDescription2(obj.pAttachments[i], "pAttachments", 0); + else + print_VkAttachmentDescription2(obj.pAttachments[i], "pAttachments", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.subpassCount, "subpassCount", 1); + + PRINT_SPACE + _OUT << "\"pSubpasses\": " << std::endl; + if (obj.pSubpasses) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.subpassCount; i++) { + if (i+1 == obj.subpassCount) + print_VkSubpassDescription2(obj.pSubpasses[i], "pSubpasses", 0); + else + print_VkSubpassDescription2(obj.pSubpasses[i], "pSubpasses", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.dependencyCount, "dependencyCount", 1); + + PRINT_SPACE + _OUT << "\"pDependencies\": " << std::endl; + if (obj.pDependencies) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.dependencyCount; i++) { + if (i+1 == obj.dependencyCount) + print_VkSubpassDependency2(obj.pDependencies[i], "pDependencies", 0); + else + print_VkSubpassDependency2(obj.pDependencies[i], "pDependencies", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.correlatedViewMaskCount, "correlatedViewMaskCount", 1); + + PRINT_SPACE + _OUT << "\"pCorrelatedViewMasks\":" << std::endl; + PRINT_SPACE + if (obj.pCorrelatedViewMasks) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.correlatedViewMaskCount; i++) { + bool isCommaNeeded = (i+1) != obj.correlatedViewMaskCount; + print_uint32_t(obj.pCorrelatedViewMasks[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2 * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkRenderPassCreateFlags(obj->flags, "flags", 1); + + print_uint32_t(obj->attachmentCount, "attachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pAttachments\": " << std::endl; + if (obj->pAttachments) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->attachmentCount; i++) { + if (i+1 == obj->attachmentCount) + print_VkAttachmentDescription2(obj->pAttachments[i], "pAttachments", 0); + else + print_VkAttachmentDescription2(obj->pAttachments[i], "pAttachments", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->subpassCount, "subpassCount", 1); + + PRINT_SPACE + _OUT << "\"pSubpasses\": " << std::endl; + if (obj->pSubpasses) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->subpassCount; i++) { + if (i+1 == obj->subpassCount) + print_VkSubpassDescription2(obj->pSubpasses[i], "pSubpasses", 0); + else + print_VkSubpassDescription2(obj->pSubpasses[i], "pSubpasses", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->dependencyCount, "dependencyCount", 1); + + PRINT_SPACE + _OUT << "\"pDependencies\": " << std::endl; + if (obj->pDependencies) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->dependencyCount; i++) { + if (i+1 == obj->dependencyCount) + print_VkSubpassDependency2(obj->pDependencies[i], "pDependencies", 0); + else + print_VkSubpassDependency2(obj->pDependencies[i], "pDependencies", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->correlatedViewMaskCount, "correlatedViewMaskCount", 1); + + PRINT_SPACE + _OUT << "\"pCorrelatedViewMasks\":" << std::endl; + PRINT_SPACE + if (obj->pCorrelatedViewMasks) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->correlatedViewMaskCount; i++) { + bool isCommaNeeded = (i+1) != obj->correlatedViewMaskCount; + print_uint32_t(obj->pCorrelatedViewMasks[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSubpassBeginInfo(VkSubpassBeginInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSubpassContents(obj.contents, "contents", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSubpassBeginInfo(const VkSubpassBeginInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSubpassContents(obj->contents, "contents", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSubpassEndInfo(VkSubpassEndInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSubpassEndInfo(const VkSubpassEndInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDevice8BitStorageFeatures(VkPhysicalDevice8BitStorageFeatures obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.storageBuffer8BitAccess, "storageBuffer8BitAccess", 1); + + print_VkBool32(obj.uniformAndStorageBuffer8BitAccess, "uniformAndStorageBuffer8BitAccess", 1); + + print_VkBool32(obj.storagePushConstant8, "storagePushConstant8", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->storageBuffer8BitAccess, "storageBuffer8BitAccess", 1); + + print_VkBool32(obj->uniformAndStorageBuffer8BitAccess, "uniformAndStorageBuffer8BitAccess", 1); + + print_VkBool32(obj->storagePushConstant8, "storagePushConstant8", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceDriverProperties(VkPhysicalDeviceDriverProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDriverId(obj.driverID, "driverID", 1); + + PRINT_SPACE + _OUT << "\"driverName\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_DRIVER_NAME_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_DRIVER_NAME_SIZE; + print_char(obj.driverName[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"driverInfo\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_DRIVER_INFO_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_DRIVER_INFO_SIZE; + print_char(obj.driverInfo[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"conformanceVersion\": " << std::endl; + { + print_VkConformanceVersion(obj.conformanceVersion, "conformanceVersion", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDriverId(obj->driverID, "driverID", 1); + + PRINT_SPACE + _OUT << "\"driverName\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_DRIVER_NAME_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_DRIVER_NAME_SIZE; + print_char(obj->driverName[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"driverInfo\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_DRIVER_INFO_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_DRIVER_INFO_SIZE; + print_char(obj->driverInfo[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"conformanceVersion\": " << std::endl; + { + print_VkConformanceVersion(obj->conformanceVersion, "conformanceVersion", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceShaderAtomicInt64Features(VkPhysicalDeviceShaderAtomicInt64Features obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.shaderBufferInt64Atomics, "shaderBufferInt64Atomics", 1); + + print_VkBool32(obj.shaderSharedInt64Atomics, "shaderSharedInt64Atomics", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->shaderBufferInt64Atomics, "shaderBufferInt64Atomics", 1); + + print_VkBool32(obj->shaderSharedInt64Atomics, "shaderSharedInt64Atomics", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceShaderFloat16Int8Features(VkPhysicalDeviceShaderFloat16Int8Features obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.shaderFloat16, "shaderFloat16", 1); + + print_VkBool32(obj.shaderInt8, "shaderInt8", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->shaderFloat16, "shaderFloat16", 1); + + print_VkBool32(obj->shaderInt8, "shaderInt8", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceFloatControlsProperties(VkPhysicalDeviceFloatControlsProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkShaderFloatControlsIndependence(obj.denormBehaviorIndependence, "denormBehaviorIndependence", 1); + + print_VkShaderFloatControlsIndependence(obj.roundingModeIndependence, "roundingModeIndependence", 1); + + print_VkBool32(obj.shaderSignedZeroInfNanPreserveFloat16, "shaderSignedZeroInfNanPreserveFloat16", 1); + + print_VkBool32(obj.shaderSignedZeroInfNanPreserveFloat32, "shaderSignedZeroInfNanPreserveFloat32", 1); + + print_VkBool32(obj.shaderSignedZeroInfNanPreserveFloat64, "shaderSignedZeroInfNanPreserveFloat64", 1); + + print_VkBool32(obj.shaderDenormPreserveFloat16, "shaderDenormPreserveFloat16", 1); + + print_VkBool32(obj.shaderDenormPreserveFloat32, "shaderDenormPreserveFloat32", 1); + + print_VkBool32(obj.shaderDenormPreserveFloat64, "shaderDenormPreserveFloat64", 1); + + print_VkBool32(obj.shaderDenormFlushToZeroFloat16, "shaderDenormFlushToZeroFloat16", 1); + + print_VkBool32(obj.shaderDenormFlushToZeroFloat32, "shaderDenormFlushToZeroFloat32", 1); + + print_VkBool32(obj.shaderDenormFlushToZeroFloat64, "shaderDenormFlushToZeroFloat64", 1); + + print_VkBool32(obj.shaderRoundingModeRTEFloat16, "shaderRoundingModeRTEFloat16", 1); + + print_VkBool32(obj.shaderRoundingModeRTEFloat32, "shaderRoundingModeRTEFloat32", 1); + + print_VkBool32(obj.shaderRoundingModeRTEFloat64, "shaderRoundingModeRTEFloat64", 1); + + print_VkBool32(obj.shaderRoundingModeRTZFloat16, "shaderRoundingModeRTZFloat16", 1); + + print_VkBool32(obj.shaderRoundingModeRTZFloat32, "shaderRoundingModeRTZFloat32", 1); + + print_VkBool32(obj.shaderRoundingModeRTZFloat64, "shaderRoundingModeRTZFloat64", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkShaderFloatControlsIndependence(obj->denormBehaviorIndependence, "denormBehaviorIndependence", 1); + + print_VkShaderFloatControlsIndependence(obj->roundingModeIndependence, "roundingModeIndependence", 1); + + print_VkBool32(obj->shaderSignedZeroInfNanPreserveFloat16, "shaderSignedZeroInfNanPreserveFloat16", 1); + + print_VkBool32(obj->shaderSignedZeroInfNanPreserveFloat32, "shaderSignedZeroInfNanPreserveFloat32", 1); + + print_VkBool32(obj->shaderSignedZeroInfNanPreserveFloat64, "shaderSignedZeroInfNanPreserveFloat64", 1); + + print_VkBool32(obj->shaderDenormPreserveFloat16, "shaderDenormPreserveFloat16", 1); + + print_VkBool32(obj->shaderDenormPreserveFloat32, "shaderDenormPreserveFloat32", 1); + + print_VkBool32(obj->shaderDenormPreserveFloat64, "shaderDenormPreserveFloat64", 1); + + print_VkBool32(obj->shaderDenormFlushToZeroFloat16, "shaderDenormFlushToZeroFloat16", 1); + + print_VkBool32(obj->shaderDenormFlushToZeroFloat32, "shaderDenormFlushToZeroFloat32", 1); + + print_VkBool32(obj->shaderDenormFlushToZeroFloat64, "shaderDenormFlushToZeroFloat64", 1); + + print_VkBool32(obj->shaderRoundingModeRTEFloat16, "shaderRoundingModeRTEFloat16", 1); + + print_VkBool32(obj->shaderRoundingModeRTEFloat32, "shaderRoundingModeRTEFloat32", 1); + + print_VkBool32(obj->shaderRoundingModeRTEFloat64, "shaderRoundingModeRTEFloat64", 1); + + print_VkBool32(obj->shaderRoundingModeRTZFloat16, "shaderRoundingModeRTZFloat16", 1); + + print_VkBool32(obj->shaderRoundingModeRTZFloat32, "shaderRoundingModeRTZFloat32", 1); + + print_VkBool32(obj->shaderRoundingModeRTZFloat64, "shaderRoundingModeRTZFloat64", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDescriptorSetLayoutBindingFlagsCreateInfo(VkDescriptorSetLayoutBindingFlagsCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.bindingCount, "bindingCount", 1); + + PRINT_SPACE + _OUT << "\"pBindingFlags\":" << std::endl; + PRINT_SPACE + if (obj.pBindingFlags) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.bindingCount; i++) { + bool isCommaNeeded = (i+1) != obj.bindingCount; + print_VkDescriptorBindingFlags(obj.pBindingFlags[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDescriptorSetLayoutBindingFlagsCreateInfo(const VkDescriptorSetLayoutBindingFlagsCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->bindingCount, "bindingCount", 1); + + PRINT_SPACE + _OUT << "\"pBindingFlags\":" << std::endl; + PRINT_SPACE + if (obj->pBindingFlags) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->bindingCount; i++) { + bool isCommaNeeded = (i+1) != obj->bindingCount; + print_VkDescriptorBindingFlags(obj->pBindingFlags[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceDescriptorIndexingFeatures(VkPhysicalDeviceDescriptorIndexingFeatures obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.shaderInputAttachmentArrayDynamicIndexing, "shaderInputAttachmentArrayDynamicIndexing", 1); + + print_VkBool32(obj.shaderUniformTexelBufferArrayDynamicIndexing, "shaderUniformTexelBufferArrayDynamicIndexing", 1); + + print_VkBool32(obj.shaderStorageTexelBufferArrayDynamicIndexing, "shaderStorageTexelBufferArrayDynamicIndexing", 1); + + print_VkBool32(obj.shaderUniformBufferArrayNonUniformIndexing, "shaderUniformBufferArrayNonUniformIndexing", 1); + + print_VkBool32(obj.shaderSampledImageArrayNonUniformIndexing, "shaderSampledImageArrayNonUniformIndexing", 1); + + print_VkBool32(obj.shaderStorageBufferArrayNonUniformIndexing, "shaderStorageBufferArrayNonUniformIndexing", 1); + + print_VkBool32(obj.shaderStorageImageArrayNonUniformIndexing, "shaderStorageImageArrayNonUniformIndexing", 1); + + print_VkBool32(obj.shaderInputAttachmentArrayNonUniformIndexing, "shaderInputAttachmentArrayNonUniformIndexing", 1); + + print_VkBool32(obj.shaderUniformTexelBufferArrayNonUniformIndexing, "shaderUniformTexelBufferArrayNonUniformIndexing", 1); + + print_VkBool32(obj.shaderStorageTexelBufferArrayNonUniformIndexing, "shaderStorageTexelBufferArrayNonUniformIndexing", 1); + + print_VkBool32(obj.descriptorBindingUniformBufferUpdateAfterBind, "descriptorBindingUniformBufferUpdateAfterBind", 1); + + print_VkBool32(obj.descriptorBindingSampledImageUpdateAfterBind, "descriptorBindingSampledImageUpdateAfterBind", 1); + + print_VkBool32(obj.descriptorBindingStorageImageUpdateAfterBind, "descriptorBindingStorageImageUpdateAfterBind", 1); + + print_VkBool32(obj.descriptorBindingStorageBufferUpdateAfterBind, "descriptorBindingStorageBufferUpdateAfterBind", 1); + + print_VkBool32(obj.descriptorBindingUniformTexelBufferUpdateAfterBind, "descriptorBindingUniformTexelBufferUpdateAfterBind", 1); + + print_VkBool32(obj.descriptorBindingStorageTexelBufferUpdateAfterBind, "descriptorBindingStorageTexelBufferUpdateAfterBind", 1); + + print_VkBool32(obj.descriptorBindingUpdateUnusedWhilePending, "descriptorBindingUpdateUnusedWhilePending", 1); + + print_VkBool32(obj.descriptorBindingPartiallyBound, "descriptorBindingPartiallyBound", 1); + + print_VkBool32(obj.descriptorBindingVariableDescriptorCount, "descriptorBindingVariableDescriptorCount", 1); + + print_VkBool32(obj.runtimeDescriptorArray, "runtimeDescriptorArray", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->shaderInputAttachmentArrayDynamicIndexing, "shaderInputAttachmentArrayDynamicIndexing", 1); + + print_VkBool32(obj->shaderUniformTexelBufferArrayDynamicIndexing, "shaderUniformTexelBufferArrayDynamicIndexing", 1); + + print_VkBool32(obj->shaderStorageTexelBufferArrayDynamicIndexing, "shaderStorageTexelBufferArrayDynamicIndexing", 1); + + print_VkBool32(obj->shaderUniformBufferArrayNonUniformIndexing, "shaderUniformBufferArrayNonUniformIndexing", 1); + + print_VkBool32(obj->shaderSampledImageArrayNonUniformIndexing, "shaderSampledImageArrayNonUniformIndexing", 1); + + print_VkBool32(obj->shaderStorageBufferArrayNonUniformIndexing, "shaderStorageBufferArrayNonUniformIndexing", 1); + + print_VkBool32(obj->shaderStorageImageArrayNonUniformIndexing, "shaderStorageImageArrayNonUniformIndexing", 1); + + print_VkBool32(obj->shaderInputAttachmentArrayNonUniformIndexing, "shaderInputAttachmentArrayNonUniformIndexing", 1); + + print_VkBool32(obj->shaderUniformTexelBufferArrayNonUniformIndexing, "shaderUniformTexelBufferArrayNonUniformIndexing", 1); + + print_VkBool32(obj->shaderStorageTexelBufferArrayNonUniformIndexing, "shaderStorageTexelBufferArrayNonUniformIndexing", 1); + + print_VkBool32(obj->descriptorBindingUniformBufferUpdateAfterBind, "descriptorBindingUniformBufferUpdateAfterBind", 1); + + print_VkBool32(obj->descriptorBindingSampledImageUpdateAfterBind, "descriptorBindingSampledImageUpdateAfterBind", 1); + + print_VkBool32(obj->descriptorBindingStorageImageUpdateAfterBind, "descriptorBindingStorageImageUpdateAfterBind", 1); + + print_VkBool32(obj->descriptorBindingStorageBufferUpdateAfterBind, "descriptorBindingStorageBufferUpdateAfterBind", 1); + + print_VkBool32(obj->descriptorBindingUniformTexelBufferUpdateAfterBind, "descriptorBindingUniformTexelBufferUpdateAfterBind", 1); + + print_VkBool32(obj->descriptorBindingStorageTexelBufferUpdateAfterBind, "descriptorBindingStorageTexelBufferUpdateAfterBind", 1); + + print_VkBool32(obj->descriptorBindingUpdateUnusedWhilePending, "descriptorBindingUpdateUnusedWhilePending", 1); + + print_VkBool32(obj->descriptorBindingPartiallyBound, "descriptorBindingPartiallyBound", 1); + + print_VkBool32(obj->descriptorBindingVariableDescriptorCount, "descriptorBindingVariableDescriptorCount", 1); + + print_VkBool32(obj->runtimeDescriptorArray, "runtimeDescriptorArray", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceDescriptorIndexingProperties(VkPhysicalDeviceDescriptorIndexingProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.maxUpdateAfterBindDescriptorsInAllPools, "maxUpdateAfterBindDescriptorsInAllPools", 1); + + print_VkBool32(obj.shaderUniformBufferArrayNonUniformIndexingNative, "shaderUniformBufferArrayNonUniformIndexingNative", 1); + + print_VkBool32(obj.shaderSampledImageArrayNonUniformIndexingNative, "shaderSampledImageArrayNonUniformIndexingNative", 1); + + print_VkBool32(obj.shaderStorageBufferArrayNonUniformIndexingNative, "shaderStorageBufferArrayNonUniformIndexingNative", 1); + + print_VkBool32(obj.shaderStorageImageArrayNonUniformIndexingNative, "shaderStorageImageArrayNonUniformIndexingNative", 1); + + print_VkBool32(obj.shaderInputAttachmentArrayNonUniformIndexingNative, "shaderInputAttachmentArrayNonUniformIndexingNative", 1); + + print_VkBool32(obj.robustBufferAccessUpdateAfterBind, "robustBufferAccessUpdateAfterBind", 1); + + print_VkBool32(obj.quadDivergentImplicitLod, "quadDivergentImplicitLod", 1); + + print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindSamplers, "maxPerStageDescriptorUpdateAfterBindSamplers", 1); + + print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindUniformBuffers, "maxPerStageDescriptorUpdateAfterBindUniformBuffers", 1); + + print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindStorageBuffers, "maxPerStageDescriptorUpdateAfterBindStorageBuffers", 1); + + print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindSampledImages, "maxPerStageDescriptorUpdateAfterBindSampledImages", 1); + + print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindStorageImages, "maxPerStageDescriptorUpdateAfterBindStorageImages", 1); + + print_uint32_t(obj.maxPerStageDescriptorUpdateAfterBindInputAttachments, "maxPerStageDescriptorUpdateAfterBindInputAttachments", 1); + + print_uint32_t(obj.maxPerStageUpdateAfterBindResources, "maxPerStageUpdateAfterBindResources", 1); + + print_uint32_t(obj.maxDescriptorSetUpdateAfterBindSamplers, "maxDescriptorSetUpdateAfterBindSamplers", 1); + + print_uint32_t(obj.maxDescriptorSetUpdateAfterBindUniformBuffers, "maxDescriptorSetUpdateAfterBindUniformBuffers", 1); + + print_uint32_t(obj.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", 1); + + print_uint32_t(obj.maxDescriptorSetUpdateAfterBindStorageBuffers, "maxDescriptorSetUpdateAfterBindStorageBuffers", 1); + + print_uint32_t(obj.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", 1); + + print_uint32_t(obj.maxDescriptorSetUpdateAfterBindSampledImages, "maxDescriptorSetUpdateAfterBindSampledImages", 1); + + print_uint32_t(obj.maxDescriptorSetUpdateAfterBindStorageImages, "maxDescriptorSetUpdateAfterBindStorageImages", 1); + + print_uint32_t(obj.maxDescriptorSetUpdateAfterBindInputAttachments, "maxDescriptorSetUpdateAfterBindInputAttachments", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->maxUpdateAfterBindDescriptorsInAllPools, "maxUpdateAfterBindDescriptorsInAllPools", 1); + + print_VkBool32(obj->shaderUniformBufferArrayNonUniformIndexingNative, "shaderUniformBufferArrayNonUniformIndexingNative", 1); + + print_VkBool32(obj->shaderSampledImageArrayNonUniformIndexingNative, "shaderSampledImageArrayNonUniformIndexingNative", 1); + + print_VkBool32(obj->shaderStorageBufferArrayNonUniformIndexingNative, "shaderStorageBufferArrayNonUniformIndexingNative", 1); + + print_VkBool32(obj->shaderStorageImageArrayNonUniformIndexingNative, "shaderStorageImageArrayNonUniformIndexingNative", 1); + + print_VkBool32(obj->shaderInputAttachmentArrayNonUniformIndexingNative, "shaderInputAttachmentArrayNonUniformIndexingNative", 1); + + print_VkBool32(obj->robustBufferAccessUpdateAfterBind, "robustBufferAccessUpdateAfterBind", 1); + + print_VkBool32(obj->quadDivergentImplicitLod, "quadDivergentImplicitLod", 1); + + print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindSamplers, "maxPerStageDescriptorUpdateAfterBindSamplers", 1); + + print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindUniformBuffers, "maxPerStageDescriptorUpdateAfterBindUniformBuffers", 1); + + print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindStorageBuffers, "maxPerStageDescriptorUpdateAfterBindStorageBuffers", 1); + + print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindSampledImages, "maxPerStageDescriptorUpdateAfterBindSampledImages", 1); + + print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindStorageImages, "maxPerStageDescriptorUpdateAfterBindStorageImages", 1); + + print_uint32_t(obj->maxPerStageDescriptorUpdateAfterBindInputAttachments, "maxPerStageDescriptorUpdateAfterBindInputAttachments", 1); + + print_uint32_t(obj->maxPerStageUpdateAfterBindResources, "maxPerStageUpdateAfterBindResources", 1); + + print_uint32_t(obj->maxDescriptorSetUpdateAfterBindSamplers, "maxDescriptorSetUpdateAfterBindSamplers", 1); + + print_uint32_t(obj->maxDescriptorSetUpdateAfterBindUniformBuffers, "maxDescriptorSetUpdateAfterBindUniformBuffers", 1); + + print_uint32_t(obj->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", 1); + + print_uint32_t(obj->maxDescriptorSetUpdateAfterBindStorageBuffers, "maxDescriptorSetUpdateAfterBindStorageBuffers", 1); + + print_uint32_t(obj->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", 1); + + print_uint32_t(obj->maxDescriptorSetUpdateAfterBindSampledImages, "maxDescriptorSetUpdateAfterBindSampledImages", 1); + + print_uint32_t(obj->maxDescriptorSetUpdateAfterBindStorageImages, "maxDescriptorSetUpdateAfterBindStorageImages", 1); + + print_uint32_t(obj->maxDescriptorSetUpdateAfterBindInputAttachments, "maxDescriptorSetUpdateAfterBindInputAttachments", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDescriptorSetVariableDescriptorCountAllocateInfo(VkDescriptorSetVariableDescriptorCountAllocateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.descriptorSetCount, "descriptorSetCount", 1); + + PRINT_SPACE + _OUT << "\"pDescriptorCounts\":" << std::endl; + PRINT_SPACE + if (obj.pDescriptorCounts) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.descriptorSetCount; i++) { + bool isCommaNeeded = (i+1) != obj.descriptorSetCount; + print_uint32_t(obj.pDescriptorCounts[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDescriptorSetVariableDescriptorCountAllocateInfo(const VkDescriptorSetVariableDescriptorCountAllocateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->descriptorSetCount, "descriptorSetCount", 1); + + PRINT_SPACE + _OUT << "\"pDescriptorCounts\":" << std::endl; + PRINT_SPACE + if (obj->pDescriptorCounts) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->descriptorSetCount; i++) { + bool isCommaNeeded = (i+1) != obj->descriptorSetCount; + print_uint32_t(obj->pDescriptorCounts[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDescriptorSetVariableDescriptorCountLayoutSupport(VkDescriptorSetVariableDescriptorCountLayoutSupport obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.maxVariableDescriptorCount, "maxVariableDescriptorCount", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDescriptorSetVariableDescriptorCountLayoutSupport(const VkDescriptorSetVariableDescriptorCountLayoutSupport * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->maxVariableDescriptorCount, "maxVariableDescriptorCount", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSubpassDescriptionDepthStencilResolve(VkSubpassDescriptionDepthStencilResolve obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkResolveModeFlagBits(obj.depthResolveMode, "depthResolveMode", 1); + + print_VkResolveModeFlagBits(obj.stencilResolveMode, "stencilResolveMode", 1); + + PRINT_SPACE + _OUT << "\"pDepthStencilResolveAttachment\": " << std::endl; + if (obj.pDepthStencilResolveAttachment) { + print_VkAttachmentReference2(obj.pDepthStencilResolveAttachment, "pDepthStencilResolveAttachment", 0); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkResolveModeFlagBits(obj->depthResolveMode, "depthResolveMode", 1); + + print_VkResolveModeFlagBits(obj->stencilResolveMode, "stencilResolveMode", 1); + + PRINT_SPACE + _OUT << "\"pDepthStencilResolveAttachment\": " << std::endl; + if (obj->pDepthStencilResolveAttachment) { + print_VkAttachmentReference2(obj->pDepthStencilResolveAttachment, "pDepthStencilResolveAttachment", 0); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceDepthStencilResolveProperties(VkPhysicalDeviceDepthStencilResolveProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkResolveModeFlags(obj.supportedDepthResolveModes, "supportedDepthResolveModes", 1); + + print_VkResolveModeFlags(obj.supportedStencilResolveModes, "supportedStencilResolveModes", 1); + + print_VkBool32(obj.independentResolveNone, "independentResolveNone", 1); + + print_VkBool32(obj.independentResolve, "independentResolve", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkResolveModeFlags(obj->supportedDepthResolveModes, "supportedDepthResolveModes", 1); + + print_VkResolveModeFlags(obj->supportedStencilResolveModes, "supportedStencilResolveModes", 1); + + print_VkBool32(obj->independentResolveNone, "independentResolveNone", 1); + + print_VkBool32(obj->independentResolve, "independentResolve", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceScalarBlockLayoutFeatures(VkPhysicalDeviceScalarBlockLayoutFeatures obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.scalarBlockLayout, "scalarBlockLayout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->scalarBlockLayout, "scalarBlockLayout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageStencilUsageCreateInfo(VkImageStencilUsageCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageUsageFlags(obj.stencilUsage, "stencilUsage", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageUsageFlags(obj->stencilUsage, "stencilUsage", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSamplerReductionModeCreateInfo(VkSamplerReductionModeCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSamplerReductionMode(obj.reductionMode, "reductionMode", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSamplerReductionMode(obj->reductionMode, "reductionMode", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceSamplerFilterMinmaxProperties(VkPhysicalDeviceSamplerFilterMinmaxProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.filterMinmaxSingleComponentFormats, "filterMinmaxSingleComponentFormats", 1); + + print_VkBool32(obj.filterMinmaxImageComponentMapping, "filterMinmaxImageComponentMapping", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->filterMinmaxSingleComponentFormats, "filterMinmaxSingleComponentFormats", 1); + + print_VkBool32(obj->filterMinmaxImageComponentMapping, "filterMinmaxImageComponentMapping", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceVulkanMemoryModelFeatures(VkPhysicalDeviceVulkanMemoryModelFeatures obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.vulkanMemoryModel, "vulkanMemoryModel", 1); + + print_VkBool32(obj.vulkanMemoryModelDeviceScope, "vulkanMemoryModelDeviceScope", 1); + + print_VkBool32(obj.vulkanMemoryModelAvailabilityVisibilityChains, "vulkanMemoryModelAvailabilityVisibilityChains", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->vulkanMemoryModel, "vulkanMemoryModel", 1); + + print_VkBool32(obj->vulkanMemoryModelDeviceScope, "vulkanMemoryModelDeviceScope", 1); + + print_VkBool32(obj->vulkanMemoryModelAvailabilityVisibilityChains, "vulkanMemoryModelAvailabilityVisibilityChains", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceImagelessFramebufferFeatures(VkPhysicalDeviceImagelessFramebufferFeatures obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.imagelessFramebuffer, "imagelessFramebuffer", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->imagelessFramebuffer, "imagelessFramebuffer", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkFramebufferAttachmentImageInfo(VkFramebufferAttachmentImageInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageCreateFlags(obj.flags, "flags", 1); + + print_VkImageUsageFlags(obj.usage, "usage", 1); + + print_uint32_t(obj.width, "width", 1); + + print_uint32_t(obj.height, "height", 1); + + print_uint32_t(obj.layerCount, "layerCount", 1); + + print_uint32_t(obj.viewFormatCount, "viewFormatCount", 1); + + PRINT_SPACE + _OUT << "\"pViewFormats\":" << std::endl; + PRINT_SPACE + if (obj.pViewFormats) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.viewFormatCount; i++) { + bool isCommaNeeded = (i+1) != obj.viewFormatCount; + print_VkFormat(obj.pViewFormats[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkFramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageCreateFlags(obj->flags, "flags", 1); + + print_VkImageUsageFlags(obj->usage, "usage", 1); + + print_uint32_t(obj->width, "width", 1); + + print_uint32_t(obj->height, "height", 1); + + print_uint32_t(obj->layerCount, "layerCount", 1); + + print_uint32_t(obj->viewFormatCount, "viewFormatCount", 1); + + PRINT_SPACE + _OUT << "\"pViewFormats\":" << std::endl; + PRINT_SPACE + if (obj->pViewFormats) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->viewFormatCount; i++) { + bool isCommaNeeded = (i+1) != obj->viewFormatCount; + print_VkFormat(obj->pViewFormats[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkFramebufferAttachmentsCreateInfo(VkFramebufferAttachmentsCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.attachmentImageInfoCount, "attachmentImageInfoCount", 1); + + PRINT_SPACE + _OUT << "\"pAttachmentImageInfos\": " << std::endl; + if (obj.pAttachmentImageInfos) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.attachmentImageInfoCount; i++) { + if (i+1 == obj.attachmentImageInfoCount) + print_VkFramebufferAttachmentImageInfo(obj.pAttachmentImageInfos[i], "pAttachmentImageInfos", 0); + else + print_VkFramebufferAttachmentImageInfo(obj.pAttachmentImageInfos[i], "pAttachmentImageInfos", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkFramebufferAttachmentsCreateInfo(const VkFramebufferAttachmentsCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->attachmentImageInfoCount, "attachmentImageInfoCount", 1); + + PRINT_SPACE + _OUT << "\"pAttachmentImageInfos\": " << std::endl; + if (obj->pAttachmentImageInfos) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->attachmentImageInfoCount; i++) { + if (i+1 == obj->attachmentImageInfoCount) + print_VkFramebufferAttachmentImageInfo(obj->pAttachmentImageInfos[i], "pAttachmentImageInfos", 0); + else + print_VkFramebufferAttachmentImageInfo(obj->pAttachmentImageInfos[i], "pAttachmentImageInfos", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkRenderPassAttachmentBeginInfo(VkRenderPassAttachmentBeginInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.attachmentCount, "attachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pAttachments\":" << std::endl; + PRINT_SPACE + if (obj.pAttachments) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.attachmentCount; i++) { + std:: stringstream tmp; + tmp << "pAttachments" << "_" << i; + bool isCommaNeeded = (i+1) != obj.attachmentCount; + print_VkImageView(obj.pAttachments[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->attachmentCount, "attachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pAttachments\":" << std::endl; + PRINT_SPACE + if (obj->pAttachments) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->attachmentCount; i++) { + std:: stringstream tmp; + tmp << "pAttachments" << "_" << i; + bool isCommaNeeded = (i+1) != obj->attachmentCount; + print_VkImageView(obj->pAttachments[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(VkPhysicalDeviceUniformBufferStandardLayoutFeatures obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.uniformBufferStandardLayout, "uniformBufferStandardLayout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->uniformBufferStandardLayout, "uniformBufferStandardLayout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.shaderSubgroupExtendedTypes, "shaderSubgroupExtendedTypes", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->shaderSubgroupExtendedTypes, "shaderSubgroupExtendedTypes", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.separateDepthStencilLayouts, "separateDepthStencilLayouts", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->separateDepthStencilLayouts, "separateDepthStencilLayouts", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkAttachmentReferenceStencilLayout(VkAttachmentReferenceStencilLayout obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageLayout(obj.stencilLayout, "stencilLayout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageLayout(obj->stencilLayout, "stencilLayout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkAttachmentDescriptionStencilLayout(VkAttachmentDescriptionStencilLayout obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageLayout(obj.stencilInitialLayout, "stencilInitialLayout", 1); + + print_VkImageLayout(obj.stencilFinalLayout, "stencilFinalLayout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageLayout(obj->stencilInitialLayout, "stencilInitialLayout", 1); + + print_VkImageLayout(obj->stencilFinalLayout, "stencilFinalLayout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceHostQueryResetFeatures(VkPhysicalDeviceHostQueryResetFeatures obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.hostQueryReset, "hostQueryReset", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->hostQueryReset, "hostQueryReset", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceTimelineSemaphoreFeatures(VkPhysicalDeviceTimelineSemaphoreFeatures obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.timelineSemaphore, "timelineSemaphore", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->timelineSemaphore, "timelineSemaphore", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceTimelineSemaphoreProperties(VkPhysicalDeviceTimelineSemaphoreProperties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint64_t(obj.maxTimelineSemaphoreValueDifference, "maxTimelineSemaphoreValueDifference", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint64_t(obj->maxTimelineSemaphoreValueDifference, "maxTimelineSemaphoreValueDifference", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSemaphoreTypeCreateInfo(VkSemaphoreTypeCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSemaphoreType(obj.semaphoreType, "semaphoreType", 1); + + print_uint64_t(obj.initialValue, "initialValue", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSemaphoreType(obj->semaphoreType, "semaphoreType", 1); + + print_uint64_t(obj->initialValue, "initialValue", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkTimelineSemaphoreSubmitInfo(VkTimelineSemaphoreSubmitInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.waitSemaphoreValueCount, "waitSemaphoreValueCount", 1); + + PRINT_SPACE + _OUT << "\"pWaitSemaphoreValues\":" << std::endl; + PRINT_SPACE + if (obj.pWaitSemaphoreValues) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.waitSemaphoreValueCount; i++) { + bool isCommaNeeded = (i+1) != obj.waitSemaphoreValueCount; + print_uint64_t(obj.pWaitSemaphoreValues[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj.signalSemaphoreValueCount, "signalSemaphoreValueCount", 1); + + PRINT_SPACE + _OUT << "\"pSignalSemaphoreValues\":" << std::endl; + PRINT_SPACE + if (obj.pSignalSemaphoreValues) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.signalSemaphoreValueCount; i++) { + bool isCommaNeeded = (i+1) != obj.signalSemaphoreValueCount; + print_uint64_t(obj.pSignalSemaphoreValues[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkTimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->waitSemaphoreValueCount, "waitSemaphoreValueCount", 1); + + PRINT_SPACE + _OUT << "\"pWaitSemaphoreValues\":" << std::endl; + PRINT_SPACE + if (obj->pWaitSemaphoreValues) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->waitSemaphoreValueCount; i++) { + bool isCommaNeeded = (i+1) != obj->waitSemaphoreValueCount; + print_uint64_t(obj->pWaitSemaphoreValues[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj->signalSemaphoreValueCount, "signalSemaphoreValueCount", 1); + + PRINT_SPACE + _OUT << "\"pSignalSemaphoreValues\":" << std::endl; + PRINT_SPACE + if (obj->pSignalSemaphoreValues) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->signalSemaphoreValueCount; i++) { + bool isCommaNeeded = (i+1) != obj->signalSemaphoreValueCount; + print_uint64_t(obj->pSignalSemaphoreValues[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSemaphoreWaitInfo(VkSemaphoreWaitInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSemaphoreWaitFlags(obj.flags, "flags", 1); + + print_uint32_t(obj.semaphoreCount, "semaphoreCount", 1); + + PRINT_SPACE + _OUT << "\"pSemaphores\":" << std::endl; + PRINT_SPACE + if (obj.pSemaphores) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.semaphoreCount; i++) { + std:: stringstream tmp; + tmp << "pSemaphores" << "_" << i; + bool isCommaNeeded = (i+1) != obj.semaphoreCount; + print_VkSemaphore(obj.pSemaphores[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + PRINT_SPACE + _OUT << "\"pValues\":" << std::endl; + PRINT_SPACE + if (obj.pValues) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.semaphoreCount; i++) { + bool isCommaNeeded = (i+1) != obj.semaphoreCount; + print_uint64_t(obj.pValues[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSemaphoreWaitFlags(obj->flags, "flags", 1); + + print_uint32_t(obj->semaphoreCount, "semaphoreCount", 1); + + PRINT_SPACE + _OUT << "\"pSemaphores\":" << std::endl; + PRINT_SPACE + if (obj->pSemaphores) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->semaphoreCount; i++) { + std:: stringstream tmp; + tmp << "pSemaphores" << "_" << i; + bool isCommaNeeded = (i+1) != obj->semaphoreCount; + print_VkSemaphore(obj->pSemaphores[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + PRINT_SPACE + _OUT << "\"pValues\":" << std::endl; + PRINT_SPACE + if (obj->pValues) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->semaphoreCount; i++) { + bool isCommaNeeded = (i+1) != obj->semaphoreCount; + print_uint64_t(obj->pValues[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSemaphoreSignalInfo(VkSemaphoreSignalInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "semaphore" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint64_t(obj.value, "value", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "semaphore" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint64_t(obj->value, "value", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceBufferDeviceAddressFeatures(VkPhysicalDeviceBufferDeviceAddressFeatures obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.bufferDeviceAddress, "bufferDeviceAddress", 1); + + print_VkBool32(obj.bufferDeviceAddressCaptureReplay, "bufferDeviceAddressCaptureReplay", 1); + + print_VkBool32(obj.bufferDeviceAddressMultiDevice, "bufferDeviceAddressMultiDevice", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->bufferDeviceAddress, "bufferDeviceAddress", 1); + + print_VkBool32(obj->bufferDeviceAddressCaptureReplay, "bufferDeviceAddressCaptureReplay", 1); + + print_VkBool32(obj->bufferDeviceAddressMultiDevice, "bufferDeviceAddressMultiDevice", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkBufferDeviceAddressInfo(VkBufferDeviceAddressInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkBufferDeviceAddressInfo(const VkBufferDeviceAddressInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkBufferOpaqueCaptureAddressCreateInfo(VkBufferOpaqueCaptureAddressCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint64_t(obj.opaqueCaptureAddress, "opaqueCaptureAddress", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkBufferOpaqueCaptureAddressCreateInfo(const VkBufferOpaqueCaptureAddressCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint64_t(obj->opaqueCaptureAddress, "opaqueCaptureAddress", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkMemoryOpaqueCaptureAddressAllocateInfo(VkMemoryOpaqueCaptureAddressAllocateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint64_t(obj.opaqueCaptureAddress, "opaqueCaptureAddress", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkMemoryOpaqueCaptureAddressAllocateInfo(const VkMemoryOpaqueCaptureAddressAllocateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint64_t(obj->opaqueCaptureAddress, "opaqueCaptureAddress", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDeviceMemoryOpaqueCaptureAddressInfo(VkDeviceMemoryOpaqueCaptureAddressInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "memory" << "\"" << " : " << "\"" << "\"" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDeviceMemoryOpaqueCaptureAddressInfo(const VkDeviceMemoryOpaqueCaptureAddressInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "memory" << "\"" << " : " << "\"" << "\"" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static std::map VkFaultLevel_map = { + std::make_pair(0, "VK_FAULT_LEVEL_UNASSIGNED"), + std::make_pair(1, "VK_FAULT_LEVEL_CRITICAL"), + std::make_pair(2, "VK_FAULT_LEVEL_RECOVERABLE"), + std::make_pair(3, "VK_FAULT_LEVEL_WARNING"), +}; +static void print_VkFaultLevel(VkFaultLevel obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFaultLevel_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFaultLevel_map[obj] << "\"" << std::endl; +} +static void print_VkFaultLevel(const VkFaultLevel * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFaultLevel_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFaultLevel_map[*obj] << "\"" << std::endl; +} + +static std::map VkFaultType_map = { + std::make_pair(0, "VK_FAULT_TYPE_INVALID"), + std::make_pair(1, "VK_FAULT_TYPE_UNASSIGNED"), + std::make_pair(2, "VK_FAULT_TYPE_IMPLEMENTATION"), + std::make_pair(3, "VK_FAULT_TYPE_SYSTEM"), + std::make_pair(4, "VK_FAULT_TYPE_PHYSICAL_DEVICE"), + std::make_pair(5, "VK_FAULT_TYPE_COMMAND_BUFFER_FULL"), + std::make_pair(6, "VK_FAULT_TYPE_INVALID_API_USAGE"), +}; +static void print_VkFaultType(VkFaultType obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFaultType_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFaultType_map[obj] << "\"" << std::endl; +} +static void print_VkFaultType(const VkFaultType * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFaultType_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFaultType_map[*obj] << "\"" << std::endl; +} + +static std::map VkFaultQueryBehavior_map = { + std::make_pair(0, "VK_FAULT_QUERY_BEHAVIOR_GET_AND_CLEAR_ALL_FAULTS"), +}; +static void print_VkFaultQueryBehavior(VkFaultQueryBehavior obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFaultQueryBehavior_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFaultQueryBehavior_map[obj] << "\"" << std::endl; +} +static void print_VkFaultQueryBehavior(const VkFaultQueryBehavior * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFaultQueryBehavior_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFaultQueryBehavior_map[*obj] << "\"" << std::endl; +} + +static std::map VkPipelineMatchControl_map = { + std::make_pair(0, "VK_PIPELINE_MATCH_CONTROL_APPLICATION_UUID_EXACT_MATCH"), +}; +static void print_VkPipelineMatchControl(VkPipelineMatchControl obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPipelineMatchControl_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPipelineMatchControl_map[obj] << "\"" << std::endl; +} +static void print_VkPipelineMatchControl(const VkPipelineMatchControl * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPipelineMatchControl_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPipelineMatchControl_map[*obj] << "\"" << std::endl; +} + +static std::map VkPipelineCacheValidationVersion_map = { + std::make_pair(1, "VK_PIPELINE_CACHE_VALIDATION_VERSION_SAFETY_CRITICAL_ONE"), +}; +static void print_VkPipelineCacheValidationVersion(VkPipelineCacheValidationVersion obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPipelineCacheValidationVersion_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPipelineCacheValidationVersion_map[obj] << "\"" << std::endl; +} +static void print_VkPipelineCacheValidationVersion(const VkPipelineCacheValidationVersion * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPipelineCacheValidationVersion_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPipelineCacheValidationVersion_map[*obj] << "\"" << std::endl; +} + +static void print_VkPhysicalDeviceVulkanSC10Features(VkPhysicalDeviceVulkanSC10Features obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.shaderAtomicInstructions, "shaderAtomicInstructions", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceVulkanSC10Features(const VkPhysicalDeviceVulkanSC10Features * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->shaderAtomicInstructions, "shaderAtomicInstructions", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceVulkanSC10Properties(VkPhysicalDeviceVulkanSC10Properties obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.deviceNoDynamicHostAllocations, "deviceNoDynamicHostAllocations", 1); + + print_VkBool32(obj.deviceDestroyFreesMemory, "deviceDestroyFreesMemory", 1); + + print_VkBool32(obj.commandPoolMultipleCommandBuffersRecording, "commandPoolMultipleCommandBuffersRecording", 1); + + print_VkBool32(obj.commandPoolResetCommandBuffer, "commandPoolResetCommandBuffer", 1); + + print_VkBool32(obj.commandBufferSimultaneousUse, "commandBufferSimultaneousUse", 1); + + print_VkBool32(obj.secondaryCommandBufferNullOrImagelessFramebuffer, "secondaryCommandBufferNullOrImagelessFramebuffer", 1); + + print_VkBool32(obj.recycleDescriptorSetMemory, "recycleDescriptorSetMemory", 1); + + print_VkBool32(obj.recyclePipelineMemory, "recyclePipelineMemory", 1); + + print_uint32_t(obj.maxRenderPassSubpasses, "maxRenderPassSubpasses", 1); + + print_uint32_t(obj.maxRenderPassDependencies, "maxRenderPassDependencies", 1); + + print_uint32_t(obj.maxSubpassInputAttachments, "maxSubpassInputAttachments", 1); + + print_uint32_t(obj.maxSubpassPreserveAttachments, "maxSubpassPreserveAttachments", 1); + + print_uint32_t(obj.maxFramebufferAttachments, "maxFramebufferAttachments", 1); + + print_uint32_t(obj.maxDescriptorSetLayoutBindings, "maxDescriptorSetLayoutBindings", 1); + + print_uint32_t(obj.maxQueryFaultCount, "maxQueryFaultCount", 1); + + print_uint32_t(obj.maxCallbackFaultCount, "maxCallbackFaultCount", 1); + + print_uint32_t(obj.maxCommandPoolCommandBuffers, "maxCommandPoolCommandBuffers", 1); + + print_VkDeviceSize(obj.maxCommandBufferSize, "maxCommandBufferSize", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceVulkanSC10Properties(const VkPhysicalDeviceVulkanSC10Properties * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->deviceNoDynamicHostAllocations, "deviceNoDynamicHostAllocations", 1); + + print_VkBool32(obj->deviceDestroyFreesMemory, "deviceDestroyFreesMemory", 1); + + print_VkBool32(obj->commandPoolMultipleCommandBuffersRecording, "commandPoolMultipleCommandBuffersRecording", 1); + + print_VkBool32(obj->commandPoolResetCommandBuffer, "commandPoolResetCommandBuffer", 1); + + print_VkBool32(obj->commandBufferSimultaneousUse, "commandBufferSimultaneousUse", 1); + + print_VkBool32(obj->secondaryCommandBufferNullOrImagelessFramebuffer, "secondaryCommandBufferNullOrImagelessFramebuffer", 1); + + print_VkBool32(obj->recycleDescriptorSetMemory, "recycleDescriptorSetMemory", 1); + + print_VkBool32(obj->recyclePipelineMemory, "recyclePipelineMemory", 1); + + print_uint32_t(obj->maxRenderPassSubpasses, "maxRenderPassSubpasses", 1); + + print_uint32_t(obj->maxRenderPassDependencies, "maxRenderPassDependencies", 1); + + print_uint32_t(obj->maxSubpassInputAttachments, "maxSubpassInputAttachments", 1); + + print_uint32_t(obj->maxSubpassPreserveAttachments, "maxSubpassPreserveAttachments", 1); + + print_uint32_t(obj->maxFramebufferAttachments, "maxFramebufferAttachments", 1); + + print_uint32_t(obj->maxDescriptorSetLayoutBindings, "maxDescriptorSetLayoutBindings", 1); + + print_uint32_t(obj->maxQueryFaultCount, "maxQueryFaultCount", 1); + + print_uint32_t(obj->maxCallbackFaultCount, "maxCallbackFaultCount", 1); + + print_uint32_t(obj->maxCommandPoolCommandBuffers, "maxCommandPoolCommandBuffers", 1); + + print_VkDeviceSize(obj->maxCommandBufferSize, "maxCommandBufferSize", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelinePoolSize(VkPipelinePoolSize obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceSize(obj.poolEntrySize, "poolEntrySize", 1); + + print_uint32_t(obj.poolEntryCount, "poolEntryCount", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelinePoolSize(const VkPipelinePoolSize * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceSize(obj->poolEntrySize, "poolEntrySize", 1); + + print_uint32_t(obj->poolEntryCount, "poolEntryCount", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDeviceObjectReservationCreateInfo(VkDeviceObjectReservationCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.pipelineCacheCreateInfoCount, "pipelineCacheCreateInfoCount", 1); + + PRINT_SPACE + _OUT << "\"pPipelineCacheCreateInfos\": " << std::endl; + if (obj.pPipelineCacheCreateInfos) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.pipelineCacheCreateInfoCount; i++) { + if (i+1 == obj.pipelineCacheCreateInfoCount) + print_VkPipelineCacheCreateInfo(obj.pPipelineCacheCreateInfos[i], "pPipelineCacheCreateInfos", 0); + else + print_VkPipelineCacheCreateInfo(obj.pPipelineCacheCreateInfos[i], "pPipelineCacheCreateInfos", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.pipelinePoolSizeCount, "pipelinePoolSizeCount", 1); + + PRINT_SPACE + _OUT << "\"pPipelinePoolSizes\": " << std::endl; + if (obj.pPipelinePoolSizes) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.pipelinePoolSizeCount; i++) { + if (i+1 == obj.pipelinePoolSizeCount) + print_VkPipelinePoolSize(obj.pPipelinePoolSizes[i], "pPipelinePoolSizes", 0); + else + print_VkPipelinePoolSize(obj.pPipelinePoolSizes[i], "pPipelinePoolSizes", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.semaphoreRequestCount, "semaphoreRequestCount", 1); + + print_uint32_t(obj.commandBufferRequestCount, "commandBufferRequestCount", 1); + + print_uint32_t(obj.fenceRequestCount, "fenceRequestCount", 1); + + print_uint32_t(obj.deviceMemoryRequestCount, "deviceMemoryRequestCount", 1); + + print_uint32_t(obj.bufferRequestCount, "bufferRequestCount", 1); + + print_uint32_t(obj.imageRequestCount, "imageRequestCount", 1); + + print_uint32_t(obj.eventRequestCount, "eventRequestCount", 1); + + print_uint32_t(obj.queryPoolRequestCount, "queryPoolRequestCount", 1); + + print_uint32_t(obj.bufferViewRequestCount, "bufferViewRequestCount", 1); + + print_uint32_t(obj.imageViewRequestCount, "imageViewRequestCount", 1); + + print_uint32_t(obj.layeredImageViewRequestCount, "layeredImageViewRequestCount", 1); + + print_uint32_t(obj.pipelineCacheRequestCount, "pipelineCacheRequestCount", 1); + + print_uint32_t(obj.pipelineLayoutRequestCount, "pipelineLayoutRequestCount", 1); + + print_uint32_t(obj.renderPassRequestCount, "renderPassRequestCount", 1); + + print_uint32_t(obj.graphicsPipelineRequestCount, "graphicsPipelineRequestCount", 1); + + print_uint32_t(obj.computePipelineRequestCount, "computePipelineRequestCount", 1); + + print_uint32_t(obj.descriptorSetLayoutRequestCount, "descriptorSetLayoutRequestCount", 1); + + print_uint32_t(obj.samplerRequestCount, "samplerRequestCount", 1); + + print_uint32_t(obj.descriptorPoolRequestCount, "descriptorPoolRequestCount", 1); + + print_uint32_t(obj.descriptorSetRequestCount, "descriptorSetRequestCount", 1); + + print_uint32_t(obj.framebufferRequestCount, "framebufferRequestCount", 1); + + print_uint32_t(obj.commandPoolRequestCount, "commandPoolRequestCount", 1); + + print_uint32_t(obj.samplerYcbcrConversionRequestCount, "samplerYcbcrConversionRequestCount", 1); + + print_uint32_t(obj.surfaceRequestCount, "surfaceRequestCount", 1); + + print_uint32_t(obj.swapchainRequestCount, "swapchainRequestCount", 1); + + print_uint32_t(obj.displayModeRequestCount, "displayModeRequestCount", 1); + + print_uint32_t(obj.subpassDescriptionRequestCount, "subpassDescriptionRequestCount", 1); + + print_uint32_t(obj.attachmentDescriptionRequestCount, "attachmentDescriptionRequestCount", 1); + + print_uint32_t(obj.descriptorSetLayoutBindingRequestCount, "descriptorSetLayoutBindingRequestCount", 1); + + print_uint32_t(obj.descriptorSetLayoutBindingLimit, "descriptorSetLayoutBindingLimit", 1); + + print_uint32_t(obj.maxImageViewMipLevels, "maxImageViewMipLevels", 1); + + print_uint32_t(obj.maxImageViewArrayLayers, "maxImageViewArrayLayers", 1); + + print_uint32_t(obj.maxLayeredImageViewMipLevels, "maxLayeredImageViewMipLevels", 1); + + print_uint32_t(obj.maxOcclusionQueriesPerPool, "maxOcclusionQueriesPerPool", 1); + + print_uint32_t(obj.maxPipelineStatisticsQueriesPerPool, "maxPipelineStatisticsQueriesPerPool", 1); + + print_uint32_t(obj.maxTimestampQueriesPerPool, "maxTimestampQueriesPerPool", 1); + + print_uint32_t(obj.maxImmutableSamplersPerDescriptorSetLayout, "maxImmutableSamplersPerDescriptorSetLayout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDeviceObjectReservationCreateInfo(const VkDeviceObjectReservationCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->pipelineCacheCreateInfoCount, "pipelineCacheCreateInfoCount", 1); + + PRINT_SPACE + _OUT << "\"pPipelineCacheCreateInfos\": " << std::endl; + if (obj->pPipelineCacheCreateInfos) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->pipelineCacheCreateInfoCount; i++) { + if (i+1 == obj->pipelineCacheCreateInfoCount) + print_VkPipelineCacheCreateInfo(obj->pPipelineCacheCreateInfos[i], "pPipelineCacheCreateInfos", 0); + else + print_VkPipelineCacheCreateInfo(obj->pPipelineCacheCreateInfos[i], "pPipelineCacheCreateInfos", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->pipelinePoolSizeCount, "pipelinePoolSizeCount", 1); + + PRINT_SPACE + _OUT << "\"pPipelinePoolSizes\": " << std::endl; + if (obj->pPipelinePoolSizes) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->pipelinePoolSizeCount; i++) { + if (i+1 == obj->pipelinePoolSizeCount) + print_VkPipelinePoolSize(obj->pPipelinePoolSizes[i], "pPipelinePoolSizes", 0); + else + print_VkPipelinePoolSize(obj->pPipelinePoolSizes[i], "pPipelinePoolSizes", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->semaphoreRequestCount, "semaphoreRequestCount", 1); + + print_uint32_t(obj->commandBufferRequestCount, "commandBufferRequestCount", 1); + + print_uint32_t(obj->fenceRequestCount, "fenceRequestCount", 1); + + print_uint32_t(obj->deviceMemoryRequestCount, "deviceMemoryRequestCount", 1); + + print_uint32_t(obj->bufferRequestCount, "bufferRequestCount", 1); + + print_uint32_t(obj->imageRequestCount, "imageRequestCount", 1); + + print_uint32_t(obj->eventRequestCount, "eventRequestCount", 1); + + print_uint32_t(obj->queryPoolRequestCount, "queryPoolRequestCount", 1); + + print_uint32_t(obj->bufferViewRequestCount, "bufferViewRequestCount", 1); + + print_uint32_t(obj->imageViewRequestCount, "imageViewRequestCount", 1); + + print_uint32_t(obj->layeredImageViewRequestCount, "layeredImageViewRequestCount", 1); + + print_uint32_t(obj->pipelineCacheRequestCount, "pipelineCacheRequestCount", 1); + + print_uint32_t(obj->pipelineLayoutRequestCount, "pipelineLayoutRequestCount", 1); + + print_uint32_t(obj->renderPassRequestCount, "renderPassRequestCount", 1); + + print_uint32_t(obj->graphicsPipelineRequestCount, "graphicsPipelineRequestCount", 1); + + print_uint32_t(obj->computePipelineRequestCount, "computePipelineRequestCount", 1); + + print_uint32_t(obj->descriptorSetLayoutRequestCount, "descriptorSetLayoutRequestCount", 1); + + print_uint32_t(obj->samplerRequestCount, "samplerRequestCount", 1); + + print_uint32_t(obj->descriptorPoolRequestCount, "descriptorPoolRequestCount", 1); + + print_uint32_t(obj->descriptorSetRequestCount, "descriptorSetRequestCount", 1); + + print_uint32_t(obj->framebufferRequestCount, "framebufferRequestCount", 1); + + print_uint32_t(obj->commandPoolRequestCount, "commandPoolRequestCount", 1); + + print_uint32_t(obj->samplerYcbcrConversionRequestCount, "samplerYcbcrConversionRequestCount", 1); + + print_uint32_t(obj->surfaceRequestCount, "surfaceRequestCount", 1); + + print_uint32_t(obj->swapchainRequestCount, "swapchainRequestCount", 1); + + print_uint32_t(obj->displayModeRequestCount, "displayModeRequestCount", 1); + + print_uint32_t(obj->subpassDescriptionRequestCount, "subpassDescriptionRequestCount", 1); + + print_uint32_t(obj->attachmentDescriptionRequestCount, "attachmentDescriptionRequestCount", 1); + + print_uint32_t(obj->descriptorSetLayoutBindingRequestCount, "descriptorSetLayoutBindingRequestCount", 1); + + print_uint32_t(obj->descriptorSetLayoutBindingLimit, "descriptorSetLayoutBindingLimit", 1); + + print_uint32_t(obj->maxImageViewMipLevels, "maxImageViewMipLevels", 1); + + print_uint32_t(obj->maxImageViewArrayLayers, "maxImageViewArrayLayers", 1); + + print_uint32_t(obj->maxLayeredImageViewMipLevels, "maxLayeredImageViewMipLevels", 1); + + print_uint32_t(obj->maxOcclusionQueriesPerPool, "maxOcclusionQueriesPerPool", 1); + + print_uint32_t(obj->maxPipelineStatisticsQueriesPerPool, "maxPipelineStatisticsQueriesPerPool", 1); + + print_uint32_t(obj->maxTimestampQueriesPerPool, "maxTimestampQueriesPerPool", 1); + + print_uint32_t(obj->maxImmutableSamplersPerDescriptorSetLayout, "maxImmutableSamplersPerDescriptorSetLayout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkCommandPoolMemoryReservationCreateInfo(VkCommandPoolMemoryReservationCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceSize(obj.commandPoolReservedSize, "commandPoolReservedSize", 1); + + print_uint32_t(obj.commandPoolMaxCommandBuffers, "commandPoolMaxCommandBuffers", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkCommandPoolMemoryReservationCreateInfo(const VkCommandPoolMemoryReservationCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceSize(obj->commandPoolReservedSize, "commandPoolReservedSize", 1); + + print_uint32_t(obj->commandPoolMaxCommandBuffers, "commandPoolMaxCommandBuffers", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkCommandPoolMemoryConsumption(VkCommandPoolMemoryConsumption obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceSize(obj.commandPoolAllocated, "commandPoolAllocated", 1); + + print_VkDeviceSize(obj.commandPoolReservedSize, "commandPoolReservedSize", 1); + + print_VkDeviceSize(obj.commandBufferAllocated, "commandBufferAllocated", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkCommandPoolMemoryConsumption(const VkCommandPoolMemoryConsumption * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceSize(obj->commandPoolAllocated, "commandPoolAllocated", 1); + + print_VkDeviceSize(obj->commandPoolReservedSize, "commandPoolReservedSize", 1); + + print_VkDeviceSize(obj->commandBufferAllocated, "commandBufferAllocated", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkFaultData(VkFaultData obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkFaultLevel(obj.faultLevel, "faultLevel", 1); + + print_VkFaultType(obj.faultType, "faultType", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkFaultData(const VkFaultData * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkFaultLevel(obj->faultLevel, "faultLevel", 1); + + print_VkFaultType(obj->faultType, "faultType", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkFaultCallbackInfo(VkFaultCallbackInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.faultCount, "faultCount", 1); + + PRINT_SPACE + _OUT << "\"pFaults\": " << std::endl; + if (obj.pFaults) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.faultCount; i++) { + if (i+1 == obj.faultCount) + print_VkFaultData(obj.pFaults[i], "pFaults", 0); + else + print_VkFaultData(obj.pFaults[i], "pFaults", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + /** Note: Ignoring function pointer (PFN_vkFaultCallbackFunction). **/ + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkFaultCallbackInfo(const VkFaultCallbackInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->faultCount, "faultCount", 1); + + PRINT_SPACE + _OUT << "\"pFaults\": " << std::endl; + if (obj->pFaults) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->faultCount; i++) { + if (i+1 == obj->faultCount) + print_VkFaultData(obj->pFaults[i], "pFaults", 0); + else + print_VkFaultData(obj->pFaults[i], "pFaults", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + /** Note: Ignoring function pointer (PFN_vkFaultCallbackFunction). **/ + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineOfflineCreateInfo(VkPipelineOfflineCreateInfo obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pipelineIdentifier\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_UUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_UUID_SIZE; + print_uint8_t(obj.pipelineIdentifier[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_VkPipelineMatchControl(obj.matchControl, "matchControl", 1); + + print_VkDeviceSize(obj.poolEntrySize, "poolEntrySize", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineOfflineCreateInfo(const VkPipelineOfflineCreateInfo * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pipelineIdentifier\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_UUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_UUID_SIZE; + print_uint8_t(obj->pipelineIdentifier[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_VkPipelineMatchControl(obj->matchControl, "matchControl", 1); + + print_VkDeviceSize(obj->poolEntrySize, "poolEntrySize", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineCacheStageValidationIndexEntry(VkPipelineCacheStageValidationIndexEntry obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint64_t(obj.codeSize, "codeSize", 1); + + print_uint64_t(obj.codeOffset, "codeOffset", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineCacheStageValidationIndexEntry(const VkPipelineCacheStageValidationIndexEntry * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint64_t(obj->codeSize, "codeSize", 1); + + print_uint64_t(obj->codeOffset, "codeOffset", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineCacheSafetyCriticalIndexEntry(VkPipelineCacheSafetyCriticalIndexEntry obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"pipelineIdentifier\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_UUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_UUID_SIZE; + print_uint8_t(obj.pipelineIdentifier[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_uint64_t(obj.pipelineMemorySize, "pipelineMemorySize", 1); + + print_uint64_t(obj.jsonSize, "jsonSize", 1); + + print_uint64_t(obj.jsonOffset, "jsonOffset", 1); + + print_uint32_t(obj.stageIndexCount, "stageIndexCount", 1); + + print_uint32_t(obj.stageIndexStride, "stageIndexStride", 1); + + print_uint64_t(obj.stageIndexOffset, "stageIndexOffset", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineCacheSafetyCriticalIndexEntry(const VkPipelineCacheSafetyCriticalIndexEntry * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"pipelineIdentifier\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_UUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_UUID_SIZE; + print_uint8_t(obj->pipelineIdentifier[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_uint64_t(obj->pipelineMemorySize, "pipelineMemorySize", 1); + + print_uint64_t(obj->jsonSize, "jsonSize", 1); + + print_uint64_t(obj->jsonOffset, "jsonOffset", 1); + + print_uint32_t(obj->stageIndexCount, "stageIndexCount", 1); + + print_uint32_t(obj->stageIndexStride, "stageIndexStride", 1); + + print_uint64_t(obj->stageIndexOffset, "stageIndexOffset", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineCacheHeaderVersionSafetyCriticalOne(VkPipelineCacheHeaderVersionSafetyCriticalOne obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"headerVersionOne\": " << std::endl; + { + print_VkPipelineCacheHeaderVersionOne(obj.headerVersionOne, "headerVersionOne", 1); + } + + print_VkPipelineCacheValidationVersion(obj.validationVersion, "validationVersion", 1); + + print_uint32_t(obj.implementationData, "implementationData", 1); + + print_uint32_t(obj.pipelineIndexCount, "pipelineIndexCount", 1); + + print_uint32_t(obj.pipelineIndexStride, "pipelineIndexStride", 1); + + print_uint64_t(obj.pipelineIndexOffset, "pipelineIndexOffset", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineCacheHeaderVersionSafetyCriticalOne(const VkPipelineCacheHeaderVersionSafetyCriticalOne * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"headerVersionOne\": " << std::endl; + { + print_VkPipelineCacheHeaderVersionOne(obj->headerVersionOne, "headerVersionOne", 1); + } + + print_VkPipelineCacheValidationVersion(obj->validationVersion, "validationVersion", 1); + + print_uint32_t(obj->implementationData, "implementationData", 1); + + print_uint32_t(obj->pipelineIndexCount, "pipelineIndexCount", 1); + + print_uint32_t(obj->pipelineIndexStride, "pipelineIndexStride", 1); + + print_uint64_t(obj->pipelineIndexOffset, "pipelineIndexOffset", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSurfaceKHR(VkSurfaceKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkSurfaceKHR(const VkSurfaceKHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static std::map VkSurfaceTransformFlagBitsKHR_map = { + std::make_pair(1ULL << 0, "VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR"), + std::make_pair(1ULL << 1, "VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR"), + std::make_pair(1ULL << 2, "VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR"), + std::make_pair(1ULL << 3, "VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR"), + std::make_pair(1ULL << 4, "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR"), + std::make_pair(1ULL << 5, "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR"), + std::make_pair(1ULL << 6, "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR"), + std::make_pair(1ULL << 7, "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR"), + std::make_pair(1ULL << 8, "VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR"), +}; +static void print_VkSurfaceTransformFlagBitsKHR(VkSurfaceTransformFlagBitsKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSurfaceTransformFlagBitsKHR_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSurfaceTransformFlagBitsKHR_map[obj] << "\"" << std::endl; +} +static void print_VkSurfaceTransformFlagBitsKHR(const VkSurfaceTransformFlagBitsKHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSurfaceTransformFlagBitsKHR_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSurfaceTransformFlagBitsKHR_map[*obj] << "\"" << std::endl; +} + +static std::map VkPresentModeKHR_map = { + std::make_pair(0, "VK_PRESENT_MODE_IMMEDIATE_KHR"), + std::make_pair(1, "VK_PRESENT_MODE_MAILBOX_KHR"), + std::make_pair(2, "VK_PRESENT_MODE_FIFO_KHR"), + std::make_pair(3, "VK_PRESENT_MODE_FIFO_RELAXED_KHR"), + std::make_pair(1000111000, "VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR"), + std::make_pair(1000111001, "VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR"), +}; +static void print_VkPresentModeKHR(VkPresentModeKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPresentModeKHR_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPresentModeKHR_map[obj] << "\"" << std::endl; +} +static void print_VkPresentModeKHR(const VkPresentModeKHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPresentModeKHR_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPresentModeKHR_map[*obj] << "\"" << std::endl; +} + +static std::map VkColorSpaceKHR_map = { + std::make_pair(0, "VK_COLOR_SPACE_SRGB_NONLINEAR_KHR"), + std::make_pair(1000104001, "VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT"), + std::make_pair(1000104002, "VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT"), + std::make_pair(1000104003, "VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT"), + std::make_pair(1000104004, "VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT"), + std::make_pair(1000104005, "VK_COLOR_SPACE_BT709_LINEAR_EXT"), + std::make_pair(1000104006, "VK_COLOR_SPACE_BT709_NONLINEAR_EXT"), + std::make_pair(1000104007, "VK_COLOR_SPACE_BT2020_LINEAR_EXT"), + std::make_pair(1000104008, "VK_COLOR_SPACE_HDR10_ST2084_EXT"), + std::make_pair(1000104009, "VK_COLOR_SPACE_DOLBYVISION_EXT"), + std::make_pair(1000104010, "VK_COLOR_SPACE_HDR10_HLG_EXT"), + std::make_pair(1000104011, "VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT"), + std::make_pair(1000104012, "VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT"), + std::make_pair(1000104013, "VK_COLOR_SPACE_PASS_THROUGH_EXT"), + std::make_pair(1000104014, "VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT"), + std::make_pair(1000213000, "VK_COLOR_SPACE_DISPLAY_NATIVE_AMD"), +}; +static void print_VkColorSpaceKHR(VkColorSpaceKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkColorSpaceKHR_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkColorSpaceKHR_map[obj] << "\"" << std::endl; +} +static void print_VkColorSpaceKHR(const VkColorSpaceKHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkColorSpaceKHR_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkColorSpaceKHR_map[*obj] << "\"" << std::endl; +} + +static std::map VkCompositeAlphaFlagBitsKHR_map = { + std::make_pair(1ULL << 0, "VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR"), + std::make_pair(1ULL << 1, "VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR"), + std::make_pair(1ULL << 2, "VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR"), + std::make_pair(1ULL << 3, "VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR"), +}; +static void print_VkCompositeAlphaFlagBitsKHR(VkCompositeAlphaFlagBitsKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkCompositeAlphaFlagBitsKHR_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkCompositeAlphaFlagBitsKHR_map[obj] << "\"" << std::endl; +} +static void print_VkCompositeAlphaFlagBitsKHR(const VkCompositeAlphaFlagBitsKHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkCompositeAlphaFlagBitsKHR_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkCompositeAlphaFlagBitsKHR_map[*obj] << "\"" << std::endl; +} + +static void print_VkCompositeAlphaFlagsKHR(VkCompositeAlphaFlagsKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + const int max_bits = 64; // We don't expect the number to be larger. + std::bitset b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkCompositeAlphaFlagBitsKHR_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkCompositeAlphaFlagBitsKHR_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkSurfaceTransformFlagBitsKHR_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkSurfaceTransformFlagBitsKHR_map[1ULL<minImageCount, "minImageCount", 1); + + print_uint32_t(obj->maxImageCount, "maxImageCount", 1); + + PRINT_SPACE + _OUT << "\"currentExtent\": " << std::endl; + { + print_VkExtent2D(obj->currentExtent, "currentExtent", 1); + } + + PRINT_SPACE + _OUT << "\"minImageExtent\": " << std::endl; + { + print_VkExtent2D(obj->minImageExtent, "minImageExtent", 1); + } + + PRINT_SPACE + _OUT << "\"maxImageExtent\": " << std::endl; + { + print_VkExtent2D(obj->maxImageExtent, "maxImageExtent", 1); + } + + print_uint32_t(obj->maxImageArrayLayers, "maxImageArrayLayers", 1); + + print_VkSurfaceTransformFlagsKHR(obj->supportedTransforms, "supportedTransforms", 1); + + print_VkSurfaceTransformFlagBitsKHR(obj->currentTransform, "currentTransform", 1); + + print_VkCompositeAlphaFlagsKHR(obj->supportedCompositeAlpha, "supportedCompositeAlpha", 1); + + print_VkImageUsageFlags(obj->supportedUsageFlags, "supportedUsageFlags", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSurfaceFormatKHR(VkSurfaceFormatKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkFormat(obj.format, "format", 1); + + print_VkColorSpaceKHR(obj.colorSpace, "colorSpace", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSurfaceFormatKHR(const VkSurfaceFormatKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkFormat(obj->format, "format", 1); + + print_VkColorSpaceKHR(obj->colorSpace, "colorSpace", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSwapchainKHR(VkSwapchainKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkSwapchainKHR(const VkSwapchainKHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static std::map VkSwapchainCreateFlagBitsKHR_map = { + std::make_pair(1ULL << 0, "VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR"), + std::make_pair(1ULL << 1, "VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR"), + std::make_pair(1ULL << 0, "VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR"), + std::make_pair(1ULL << 2, "VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR"), +}; +static void print_VkSwapchainCreateFlagBitsKHR(VkSwapchainCreateFlagBitsKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSwapchainCreateFlagBitsKHR_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSwapchainCreateFlagBitsKHR_map[obj] << "\"" << std::endl; +} +static void print_VkSwapchainCreateFlagBitsKHR(const VkSwapchainCreateFlagBitsKHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSwapchainCreateFlagBitsKHR_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSwapchainCreateFlagBitsKHR_map[*obj] << "\"" << std::endl; +} + +static std::map VkDeviceGroupPresentModeFlagBitsKHR_map = { + std::make_pair(1ULL << 0, "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR"), + std::make_pair(1ULL << 1, "VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR"), + std::make_pair(1ULL << 2, "VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR"), + std::make_pair(1ULL << 3, "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR"), +}; +static void print_VkDeviceGroupPresentModeFlagBitsKHR(VkDeviceGroupPresentModeFlagBitsKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDeviceGroupPresentModeFlagBitsKHR_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDeviceGroupPresentModeFlagBitsKHR_map[obj] << "\"" << std::endl; +} +static void print_VkDeviceGroupPresentModeFlagBitsKHR(const VkDeviceGroupPresentModeFlagBitsKHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDeviceGroupPresentModeFlagBitsKHR_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDeviceGroupPresentModeFlagBitsKHR_map[*obj] << "\"" << std::endl; +} + +static void print_VkSwapchainCreateFlagsKHR(VkSwapchainCreateFlagsKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + const int max_bits = 64; // We don't expect the number to be larger. + std::bitset b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkSwapchainCreateFlagBitsKHR_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkSwapchainCreateFlagBitsKHR_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkDeviceGroupPresentModeFlagBitsKHR_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkDeviceGroupPresentModeFlagBitsKHR_map[1ULL<sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSwapchainCreateFlagsKHR(obj->flags, "flags", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "surface" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj->minImageCount, "minImageCount", 1); + + print_VkFormat(obj->imageFormat, "imageFormat", 1); + + print_VkColorSpaceKHR(obj->imageColorSpace, "imageColorSpace", 1); + + PRINT_SPACE + _OUT << "\"imageExtent\": " << std::endl; + { + print_VkExtent2D(obj->imageExtent, "imageExtent", 1); + } + + print_uint32_t(obj->imageArrayLayers, "imageArrayLayers", 1); + + print_VkImageUsageFlags(obj->imageUsage, "imageUsage", 1); + + print_VkSharingMode(obj->imageSharingMode, "imageSharingMode", 1); + + print_uint32_t(obj->queueFamilyIndexCount, "queueFamilyIndexCount", 1); + + PRINT_SPACE + _OUT << "\"pQueueFamilyIndices\":" << std::endl; + PRINT_SPACE + if (obj->pQueueFamilyIndices) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->queueFamilyIndexCount; i++) { + bool isCommaNeeded = (i+1) != obj->queueFamilyIndexCount; + print_uint32_t(obj->pQueueFamilyIndices[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_VkSurfaceTransformFlagBitsKHR(obj->preTransform, "preTransform", 1); + + print_VkCompositeAlphaFlagBitsKHR(obj->compositeAlpha, "compositeAlpha", 1); + + print_VkPresentModeKHR(obj->presentMode, "presentMode", 1); + + print_VkBool32(obj->clipped, "clipped", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "oldSwapchain" << "\"" << " : " << "\"" << "\"" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPresentInfoKHR(VkPresentInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.waitSemaphoreCount, "waitSemaphoreCount", 1); + + PRINT_SPACE + _OUT << "\"pWaitSemaphores\":" << std::endl; + PRINT_SPACE + if (obj.pWaitSemaphores) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.waitSemaphoreCount; i++) { + std:: stringstream tmp; + tmp << "pWaitSemaphores" << "_" << i; + bool isCommaNeeded = (i+1) != obj.waitSemaphoreCount; + print_VkSemaphore(obj.pWaitSemaphores[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj.swapchainCount, "swapchainCount", 1); + + PRINT_SPACE + _OUT << "\"pSwapchains\":" << std::endl; + PRINT_SPACE + if (obj.pSwapchains) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.swapchainCount; i++) { + std:: stringstream tmp; + tmp << "pSwapchains" << "_" << i; + bool isCommaNeeded = (i+1) != obj.swapchainCount; + print_VkSwapchainKHR(obj.pSwapchains[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + PRINT_SPACE + _OUT << "\"pImageIndices\":" << std::endl; + PRINT_SPACE + if (obj.pImageIndices) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.swapchainCount; i++) { + bool isCommaNeeded = (i+1) != obj.swapchainCount; + print_uint32_t(obj.pImageIndices[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + PRINT_SPACE + _OUT << "\"pResults\":" << std::endl; + PRINT_SPACE + if (obj.pResults) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.swapchainCount; i++) { + bool isCommaNeeded = (i+1) != obj.swapchainCount; + print_VkResult(obj.pResults[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPresentInfoKHR(const VkPresentInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->waitSemaphoreCount, "waitSemaphoreCount", 1); + + PRINT_SPACE + _OUT << "\"pWaitSemaphores\":" << std::endl; + PRINT_SPACE + if (obj->pWaitSemaphores) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->waitSemaphoreCount; i++) { + std:: stringstream tmp; + tmp << "pWaitSemaphores" << "_" << i; + bool isCommaNeeded = (i+1) != obj->waitSemaphoreCount; + print_VkSemaphore(obj->pWaitSemaphores[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj->swapchainCount, "swapchainCount", 1); + + PRINT_SPACE + _OUT << "\"pSwapchains\":" << std::endl; + PRINT_SPACE + if (obj->pSwapchains) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->swapchainCount; i++) { + std:: stringstream tmp; + tmp << "pSwapchains" << "_" << i; + bool isCommaNeeded = (i+1) != obj->swapchainCount; + print_VkSwapchainKHR(obj->pSwapchains[i], tmp.str(), isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + PRINT_SPACE + _OUT << "\"pImageIndices\":" << std::endl; + PRINT_SPACE + if (obj->pImageIndices) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->swapchainCount; i++) { + bool isCommaNeeded = (i+1) != obj->swapchainCount; + print_uint32_t(obj->pImageIndices[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + PRINT_SPACE + _OUT << "\"pResults\":" << std::endl; + PRINT_SPACE + if (obj->pResults) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->swapchainCount; i++) { + bool isCommaNeeded = (i+1) != obj->swapchainCount; + print_VkResult(obj->pResults[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageSwapchainCreateInfoKHR(VkImageSwapchainCreateInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "swapchain" << "\"" << " : " << "\"" << "\"" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "swapchain" << "\"" << " : " << "\"" << "\"" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkBindImageMemorySwapchainInfoKHR(VkBindImageMemorySwapchainInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "swapchain" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj.imageIndex, "imageIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkBindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "swapchain" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj->imageIndex, "imageIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkAcquireNextImageInfoKHR(VkAcquireNextImageInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "swapchain" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint64_t(obj.timeout, "timeout", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "semaphore" << "\"" << " : " << "\"" << "\"," << std::endl; + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "fence" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj.deviceMask, "deviceMask", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkAcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "swapchain" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint64_t(obj->timeout, "timeout", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "semaphore" << "\"" << " : " << "\"" << "\"," << std::endl; + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "fence" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj->deviceMask, "deviceMask", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDeviceGroupPresentCapabilitiesKHR(VkDeviceGroupPresentCapabilitiesKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"presentMask\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_DEVICE_GROUP_SIZE; + print_uint32_t(obj.presentMask[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_VkDeviceGroupPresentModeFlagsKHR(obj.modes, "modes", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDeviceGroupPresentCapabilitiesKHR(const VkDeviceGroupPresentCapabilitiesKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"presentMask\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_DEVICE_GROUP_SIZE; + print_uint32_t(obj->presentMask[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_VkDeviceGroupPresentModeFlagsKHR(obj->modes, "modes", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDeviceGroupPresentInfoKHR(VkDeviceGroupPresentInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.swapchainCount, "swapchainCount", 1); + + PRINT_SPACE + _OUT << "\"pDeviceMasks\":" << std::endl; + PRINT_SPACE + if (obj.pDeviceMasks) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.swapchainCount; i++) { + bool isCommaNeeded = (i+1) != obj.swapchainCount; + print_uint32_t(obj.pDeviceMasks[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_VkDeviceGroupPresentModeFlagBitsKHR(obj.mode, "mode", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->swapchainCount, "swapchainCount", 1); + + PRINT_SPACE + _OUT << "\"pDeviceMasks\":" << std::endl; + PRINT_SPACE + if (obj->pDeviceMasks) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->swapchainCount; i++) { + bool isCommaNeeded = (i+1) != obj->swapchainCount; + print_uint32_t(obj->pDeviceMasks[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_VkDeviceGroupPresentModeFlagBitsKHR(obj->mode, "mode", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDeviceGroupSwapchainCreateInfoKHR(VkDeviceGroupSwapchainCreateInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceGroupPresentModeFlagsKHR(obj.modes, "modes", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDeviceGroupSwapchainCreateInfoKHR(const VkDeviceGroupSwapchainCreateInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceGroupPresentModeFlagsKHR(obj->modes, "modes", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDisplayKHR(VkDisplayKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkDisplayKHR(const VkDisplayKHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static void print_VkDisplayModeKHR(VkDisplayModeKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkDisplayModeKHR(const VkDisplayModeKHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static std::map VkDisplayPlaneAlphaFlagBitsKHR_map = { + std::make_pair(1ULL << 0, "VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR"), + std::make_pair(1ULL << 1, "VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR"), + std::make_pair(1ULL << 2, "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR"), + std::make_pair(1ULL << 3, "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR"), +}; +static void print_VkDisplayPlaneAlphaFlagBitsKHR(VkDisplayPlaneAlphaFlagBitsKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDisplayPlaneAlphaFlagBitsKHR_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDisplayPlaneAlphaFlagBitsKHR_map[obj] << "\"" << std::endl; +} +static void print_VkDisplayPlaneAlphaFlagBitsKHR(const VkDisplayPlaneAlphaFlagBitsKHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDisplayPlaneAlphaFlagBitsKHR_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDisplayPlaneAlphaFlagBitsKHR_map[*obj] << "\"" << std::endl; +} + +static void print_VkDisplayModeCreateFlagsKHR(VkDisplayModeCreateFlagsKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl; + else + _OUT << "\"" << str << "\"" << " : " << obj << std::endl; +} +static void print_VkDisplayModeCreateFlagsKHR(const VkDisplayModeCreateFlagsKHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl; + else + _OUT << "\"" << str << "\"" << " : " << obj << std::endl; +} + +static void print_VkDisplayPlaneAlphaFlagsKHR(VkDisplayPlaneAlphaFlagsKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + const int max_bits = 64; // We don't expect the number to be larger. + std::bitset b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkDisplayPlaneAlphaFlagBitsKHR_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkDisplayPlaneAlphaFlagBitsKHR_map[1ULL<visibleRegion, "visibleRegion", 1); + } + + print_uint32_t(obj->refreshRate, "refreshRate", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDisplayModeCreateInfoKHR(VkDisplayModeCreateInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDisplayModeCreateFlagsKHR(obj.flags, "flags", 1); + + PRINT_SPACE + _OUT << "\"parameters\": " << std::endl; + { + print_VkDisplayModeParametersKHR(obj.parameters, "parameters", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDisplayModeCreateFlagsKHR(obj->flags, "flags", 1); + + PRINT_SPACE + _OUT << "\"parameters\": " << std::endl; + { + print_VkDisplayModeParametersKHR(obj->parameters, "parameters", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDisplayModePropertiesKHR(VkDisplayModePropertiesKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "displayMode" << "\"" << " : " << "\"" << "\"," << std::endl; + + PRINT_SPACE + _OUT << "\"parameters\": " << std::endl; + { + print_VkDisplayModeParametersKHR(obj.parameters, "parameters", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDisplayModePropertiesKHR(const VkDisplayModePropertiesKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "displayMode" << "\"" << " : " << "\"" << "\"," << std::endl; + + PRINT_SPACE + _OUT << "\"parameters\": " << std::endl; + { + print_VkDisplayModeParametersKHR(obj->parameters, "parameters", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDisplayPlaneCapabilitiesKHR(VkDisplayPlaneCapabilitiesKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkDisplayPlaneAlphaFlagsKHR(obj.supportedAlpha, "supportedAlpha", 1); + + PRINT_SPACE + _OUT << "\"minSrcPosition\": " << std::endl; + { + print_VkOffset2D(obj.minSrcPosition, "minSrcPosition", 1); + } + + PRINT_SPACE + _OUT << "\"maxSrcPosition\": " << std::endl; + { + print_VkOffset2D(obj.maxSrcPosition, "maxSrcPosition", 1); + } + + PRINT_SPACE + _OUT << "\"minSrcExtent\": " << std::endl; + { + print_VkExtent2D(obj.minSrcExtent, "minSrcExtent", 1); + } + + PRINT_SPACE + _OUT << "\"maxSrcExtent\": " << std::endl; + { + print_VkExtent2D(obj.maxSrcExtent, "maxSrcExtent", 1); + } + + PRINT_SPACE + _OUT << "\"minDstPosition\": " << std::endl; + { + print_VkOffset2D(obj.minDstPosition, "minDstPosition", 1); + } + + PRINT_SPACE + _OUT << "\"maxDstPosition\": " << std::endl; + { + print_VkOffset2D(obj.maxDstPosition, "maxDstPosition", 1); + } + + PRINT_SPACE + _OUT << "\"minDstExtent\": " << std::endl; + { + print_VkExtent2D(obj.minDstExtent, "minDstExtent", 1); + } + + PRINT_SPACE + _OUT << "\"maxDstExtent\": " << std::endl; + { + print_VkExtent2D(obj.maxDstExtent, "maxDstExtent", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDisplayPlaneCapabilitiesKHR(const VkDisplayPlaneCapabilitiesKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkDisplayPlaneAlphaFlagsKHR(obj->supportedAlpha, "supportedAlpha", 1); + + PRINT_SPACE + _OUT << "\"minSrcPosition\": " << std::endl; + { + print_VkOffset2D(obj->minSrcPosition, "minSrcPosition", 1); + } + + PRINT_SPACE + _OUT << "\"maxSrcPosition\": " << std::endl; + { + print_VkOffset2D(obj->maxSrcPosition, "maxSrcPosition", 1); + } + + PRINT_SPACE + _OUT << "\"minSrcExtent\": " << std::endl; + { + print_VkExtent2D(obj->minSrcExtent, "minSrcExtent", 1); + } + + PRINT_SPACE + _OUT << "\"maxSrcExtent\": " << std::endl; + { + print_VkExtent2D(obj->maxSrcExtent, "maxSrcExtent", 1); + } + + PRINT_SPACE + _OUT << "\"minDstPosition\": " << std::endl; + { + print_VkOffset2D(obj->minDstPosition, "minDstPosition", 1); + } + + PRINT_SPACE + _OUT << "\"maxDstPosition\": " << std::endl; + { + print_VkOffset2D(obj->maxDstPosition, "maxDstPosition", 1); + } + + PRINT_SPACE + _OUT << "\"minDstExtent\": " << std::endl; + { + print_VkExtent2D(obj->minDstExtent, "minDstExtent", 1); + } + + PRINT_SPACE + _OUT << "\"maxDstExtent\": " << std::endl; + { + print_VkExtent2D(obj->maxDstExtent, "maxDstExtent", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDisplayPlanePropertiesKHR(VkDisplayPlanePropertiesKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "currentDisplay" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj.currentStackIndex, "currentStackIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDisplayPlanePropertiesKHR(const VkDisplayPlanePropertiesKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "currentDisplay" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj->currentStackIndex, "currentStackIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDisplayPropertiesKHR(VkDisplayPropertiesKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "display" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_char(obj.displayName, "displayName", 1); + + PRINT_SPACE + _OUT << "\"physicalDimensions\": " << std::endl; + { + print_VkExtent2D(obj.physicalDimensions, "physicalDimensions", 1); + } + + PRINT_SPACE + _OUT << "\"physicalResolution\": " << std::endl; + { + print_VkExtent2D(obj.physicalResolution, "physicalResolution", 1); + } + + print_VkSurfaceTransformFlagsKHR(obj.supportedTransforms, "supportedTransforms", 1); + + print_VkBool32(obj.planeReorderPossible, "planeReorderPossible", 1); + + print_VkBool32(obj.persistentContent, "persistentContent", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "display" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_char(obj->displayName, "displayName", 1); + + PRINT_SPACE + _OUT << "\"physicalDimensions\": " << std::endl; + { + print_VkExtent2D(obj->physicalDimensions, "physicalDimensions", 1); + } + + PRINT_SPACE + _OUT << "\"physicalResolution\": " << std::endl; + { + print_VkExtent2D(obj->physicalResolution, "physicalResolution", 1); + } + + print_VkSurfaceTransformFlagsKHR(obj->supportedTransforms, "supportedTransforms", 1); + + print_VkBool32(obj->planeReorderPossible, "planeReorderPossible", 1); + + print_VkBool32(obj->persistentContent, "persistentContent", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDisplaySurfaceCreateInfoKHR(VkDisplaySurfaceCreateInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDisplaySurfaceCreateFlagsKHR(obj.flags, "flags", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "displayMode" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj.planeIndex, "planeIndex", 1); + + print_uint32_t(obj.planeStackIndex, "planeStackIndex", 1); + + print_VkSurfaceTransformFlagBitsKHR(obj.transform, "transform", 1); + + print_float(obj.globalAlpha, "globalAlpha", 1); + + print_VkDisplayPlaneAlphaFlagBitsKHR(obj.alphaMode, "alphaMode", 1); + + PRINT_SPACE + _OUT << "\"imageExtent\": " << std::endl; + { + print_VkExtent2D(obj.imageExtent, "imageExtent", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDisplaySurfaceCreateFlagsKHR(obj->flags, "flags", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "displayMode" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj->planeIndex, "planeIndex", 1); + + print_uint32_t(obj->planeStackIndex, "planeStackIndex", 1); + + print_VkSurfaceTransformFlagBitsKHR(obj->transform, "transform", 1); + + print_float(obj->globalAlpha, "globalAlpha", 1); + + print_VkDisplayPlaneAlphaFlagBitsKHR(obj->alphaMode, "alphaMode", 1); + + PRINT_SPACE + _OUT << "\"imageExtent\": " << std::endl; + { + print_VkExtent2D(obj->imageExtent, "imageExtent", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDisplayPresentInfoKHR(VkDisplayPresentInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"srcRect\": " << std::endl; + { + print_VkRect2D(obj.srcRect, "srcRect", 1); + } + + PRINT_SPACE + _OUT << "\"dstRect\": " << std::endl; + { + print_VkRect2D(obj.dstRect, "dstRect", 1); + } + + print_VkBool32(obj.persistent, "persistent", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"srcRect\": " << std::endl; + { + print_VkRect2D(obj->srcRect, "srcRect", 1); + } + + PRINT_SPACE + _OUT << "\"dstRect\": " << std::endl; + { + print_VkRect2D(obj->dstRect, "dstRect", 1); + } + + print_VkBool32(obj->persistent, "persistent", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImportMemoryFdInfoKHR(VkImportMemoryFdInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalMemoryHandleTypeFlagBits(obj.handleType, "handleType", 1); + + print_int(obj.fd, "fd", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalMemoryHandleTypeFlagBits(obj->handleType, "handleType", 1); + + print_int(obj->fd, "fd", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkMemoryFdPropertiesKHR(VkMemoryFdPropertiesKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.memoryTypeBits, "memoryTypeBits", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->memoryTypeBits, "memoryTypeBits", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkMemoryGetFdInfoKHR(VkMemoryGetFdInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "memory" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkExternalMemoryHandleTypeFlagBits(obj.handleType, "handleType", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "memory" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkExternalMemoryHandleTypeFlagBits(obj->handleType, "handleType", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImportSemaphoreFdInfoKHR(VkImportSemaphoreFdInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "semaphore" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkSemaphoreImportFlags(obj.flags, "flags", 1); + + print_VkExternalSemaphoreHandleTypeFlagBits(obj.handleType, "handleType", 1); + + print_int(obj.fd, "fd", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "semaphore" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkSemaphoreImportFlags(obj->flags, "flags", 1); + + print_VkExternalSemaphoreHandleTypeFlagBits(obj->handleType, "handleType", 1); + + print_int(obj->fd, "fd", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSemaphoreGetFdInfoKHR(VkSemaphoreGetFdInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "semaphore" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkExternalSemaphoreHandleTypeFlagBits(obj.handleType, "handleType", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "semaphore" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkExternalSemaphoreHandleTypeFlagBits(obj->handleType, "handleType", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkRectLayerKHR(VkRectLayerKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"offset\": " << std::endl; + { + print_VkOffset2D(obj.offset, "offset", 1); + } + + PRINT_SPACE + _OUT << "\"extent\": " << std::endl; + { + print_VkExtent2D(obj.extent, "extent", 1); + } + + print_uint32_t(obj.layer, "layer", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkRectLayerKHR(const VkRectLayerKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + PRINT_SPACE + _OUT << "\"offset\": " << std::endl; + { + print_VkOffset2D(obj->offset, "offset", 1); + } + + PRINT_SPACE + _OUT << "\"extent\": " << std::endl; + { + print_VkExtent2D(obj->extent, "extent", 1); + } + + print_uint32_t(obj->layer, "layer", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPresentRegionKHR(VkPresentRegionKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj.rectangleCount, "rectangleCount", 1); + + PRINT_SPACE + _OUT << "\"pRectangles\": " << std::endl; + if (obj.pRectangles) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.rectangleCount; i++) { + if (i+1 == obj.rectangleCount) + print_VkRectLayerKHR(obj.pRectangles[i], "pRectangles", 0); + else + print_VkRectLayerKHR(obj.pRectangles[i], "pRectangles", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPresentRegionKHR(const VkPresentRegionKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj->rectangleCount, "rectangleCount", 1); + + PRINT_SPACE + _OUT << "\"pRectangles\": " << std::endl; + if (obj->pRectangles) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->rectangleCount; i++) { + if (i+1 == obj->rectangleCount) + print_VkRectLayerKHR(obj->pRectangles[i], "pRectangles", 0); + else + print_VkRectLayerKHR(obj->pRectangles[i], "pRectangles", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPresentRegionsKHR(VkPresentRegionsKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.swapchainCount, "swapchainCount", 1); + + PRINT_SPACE + _OUT << "\"pRegions\": " << std::endl; + if (obj.pRegions) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.swapchainCount; i++) { + if (i+1 == obj.swapchainCount) + print_VkPresentRegionKHR(obj.pRegions[i], "pRegions", 0); + else + print_VkPresentRegionKHR(obj.pRegions[i], "pRegions", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPresentRegionsKHR(const VkPresentRegionsKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->swapchainCount, "swapchainCount", 1); + + PRINT_SPACE + _OUT << "\"pRegions\": " << std::endl; + if (obj->pRegions) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->swapchainCount; i++) { + if (i+1 == obj->swapchainCount) + print_VkPresentRegionKHR(obj->pRegions[i], "pRegions", 0); + else + print_VkPresentRegionKHR(obj->pRegions[i], "pRegions", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSharedPresentSurfaceCapabilitiesKHR(VkSharedPresentSurfaceCapabilitiesKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageUsageFlags(obj.sharedPresentSupportedUsageFlags, "sharedPresentSupportedUsageFlags", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSharedPresentSurfaceCapabilitiesKHR(const VkSharedPresentSurfaceCapabilitiesKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageUsageFlags(obj->sharedPresentSupportedUsageFlags, "sharedPresentSupportedUsageFlags", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImportFenceFdInfoKHR(VkImportFenceFdInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "fence" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkFenceImportFlags(obj.flags, "flags", 1); + + print_VkExternalFenceHandleTypeFlagBits(obj.handleType, "handleType", 1); + + print_int(obj.fd, "fd", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "fence" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkFenceImportFlags(obj->flags, "flags", 1); + + print_VkExternalFenceHandleTypeFlagBits(obj->handleType, "handleType", 1); + + print_int(obj->fd, "fd", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkFenceGetFdInfoKHR(VkFenceGetFdInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "fence" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkExternalFenceHandleTypeFlagBits(obj.handleType, "handleType", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "fence" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkExternalFenceHandleTypeFlagBits(obj->handleType, "handleType", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static std::map VkPerformanceCounterUnitKHR_map = { + std::make_pair(0, "VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR"), + std::make_pair(1, "VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR"), + std::make_pair(2, "VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR"), + std::make_pair(3, "VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR"), + std::make_pair(4, "VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR"), + std::make_pair(5, "VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR"), + std::make_pair(6, "VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR"), + std::make_pair(7, "VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR"), + std::make_pair(8, "VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR"), + std::make_pair(9, "VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR"), + std::make_pair(10, "VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR"), +}; +static void print_VkPerformanceCounterUnitKHR(VkPerformanceCounterUnitKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPerformanceCounterUnitKHR_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPerformanceCounterUnitKHR_map[obj] << "\"" << std::endl; +} +static void print_VkPerformanceCounterUnitKHR(const VkPerformanceCounterUnitKHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPerformanceCounterUnitKHR_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPerformanceCounterUnitKHR_map[*obj] << "\"" << std::endl; +} + +static std::map VkPerformanceCounterScopeKHR_map = { + std::make_pair(0, "VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR"), + std::make_pair(1, "VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR"), + std::make_pair(2, "VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR"), +}; +static void print_VkPerformanceCounterScopeKHR(VkPerformanceCounterScopeKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPerformanceCounterScopeKHR_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPerformanceCounterScopeKHR_map[obj] << "\"" << std::endl; +} +static void print_VkPerformanceCounterScopeKHR(const VkPerformanceCounterScopeKHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPerformanceCounterScopeKHR_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPerformanceCounterScopeKHR_map[*obj] << "\"" << std::endl; +} + +static std::map VkPerformanceCounterStorageKHR_map = { + std::make_pair(0, "VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR"), + std::make_pair(1, "VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR"), + std::make_pair(2, "VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR"), + std::make_pair(3, "VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR"), + std::make_pair(4, "VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR"), + std::make_pair(5, "VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR"), +}; +static void print_VkPerformanceCounterStorageKHR(VkPerformanceCounterStorageKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPerformanceCounterStorageKHR_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPerformanceCounterStorageKHR_map[obj] << "\"" << std::endl; +} +static void print_VkPerformanceCounterStorageKHR(const VkPerformanceCounterStorageKHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPerformanceCounterStorageKHR_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPerformanceCounterStorageKHR_map[*obj] << "\"" << std::endl; +} + +static std::map VkPerformanceCounterDescriptionFlagBitsKHR_map = { + std::make_pair(1ULL << 0, "VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR"), + std::make_pair(1ULL << 1, "VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR"), +}; +static void print_VkPerformanceCounterDescriptionFlagBitsKHR(VkPerformanceCounterDescriptionFlagBitsKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPerformanceCounterDescriptionFlagBitsKHR_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPerformanceCounterDescriptionFlagBitsKHR_map[obj] << "\"" << std::endl; +} +static void print_VkPerformanceCounterDescriptionFlagBitsKHR(const VkPerformanceCounterDescriptionFlagBitsKHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPerformanceCounterDescriptionFlagBitsKHR_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPerformanceCounterDescriptionFlagBitsKHR_map[*obj] << "\"" << std::endl; +} + +static std::map VkAcquireProfilingLockFlagBitsKHR_map = { +}; +static void print_VkAcquireProfilingLockFlagBitsKHR(VkAcquireProfilingLockFlagBitsKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkAcquireProfilingLockFlagBitsKHR_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkAcquireProfilingLockFlagBitsKHR_map[obj] << "\"" << std::endl; +} +static void print_VkAcquireProfilingLockFlagBitsKHR(const VkAcquireProfilingLockFlagBitsKHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkAcquireProfilingLockFlagBitsKHR_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkAcquireProfilingLockFlagBitsKHR_map[*obj] << "\"" << std::endl; +} + +static void print_VkPerformanceCounterDescriptionFlagsKHR(VkPerformanceCounterDescriptionFlagsKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + const int max_bits = 64; // We don't expect the number to be larger. + std::bitset b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkPerformanceCounterDescriptionFlagBitsKHR_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkPerformanceCounterDescriptionFlagBitsKHR_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkAcquireProfilingLockFlagBitsKHR_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkAcquireProfilingLockFlagBitsKHR_map[1ULL<sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->performanceCounterQueryPools, "performanceCounterQueryPools", 1); + + print_VkBool32(obj->performanceCounterMultipleQueryPools, "performanceCounterMultipleQueryPools", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDevicePerformanceQueryPropertiesKHR(VkPhysicalDevicePerformanceQueryPropertiesKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.allowCommandBufferQueryCopies, "allowCommandBufferQueryCopies", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDevicePerformanceQueryPropertiesKHR(const VkPhysicalDevicePerformanceQueryPropertiesKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->allowCommandBufferQueryCopies, "allowCommandBufferQueryCopies", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPerformanceCounterKHR(VkPerformanceCounterKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPerformanceCounterUnitKHR(obj.unit, "unit", 1); + + print_VkPerformanceCounterScopeKHR(obj.scope, "scope", 1); + + print_VkPerformanceCounterStorageKHR(obj.storage, "storage", 1); + + PRINT_SPACE + _OUT << "\"uuid\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_UUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_UUID_SIZE; + print_uint8_t(obj.uuid[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPerformanceCounterKHR(const VkPerformanceCounterKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPerformanceCounterUnitKHR(obj->unit, "unit", 1); + + print_VkPerformanceCounterScopeKHR(obj->scope, "scope", 1); + + print_VkPerformanceCounterStorageKHR(obj->storage, "storage", 1); + + PRINT_SPACE + _OUT << "\"uuid\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_UUID_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_UUID_SIZE; + print_uint8_t(obj->uuid[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPerformanceCounterDescriptionKHR(VkPerformanceCounterDescriptionKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPerformanceCounterDescriptionFlagsKHR(obj.flags, "flags", 1); + + PRINT_SPACE + _OUT << "\"name\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_DESCRIPTION_SIZE; + print_char(obj.name[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"category\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_DESCRIPTION_SIZE; + print_char(obj.category[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"description\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_DESCRIPTION_SIZE; + print_char(obj.description[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPerformanceCounterDescriptionKHR(const VkPerformanceCounterDescriptionKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPerformanceCounterDescriptionFlagsKHR(obj->flags, "flags", 1); + + PRINT_SPACE + _OUT << "\"name\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_DESCRIPTION_SIZE; + print_char(obj->name[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"category\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_DESCRIPTION_SIZE; + print_char(obj->category[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"description\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_DESCRIPTION_SIZE; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_DESCRIPTION_SIZE; + print_char(obj->description[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkQueryPoolPerformanceCreateInfoKHR(VkQueryPoolPerformanceCreateInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.queueFamilyIndex, "queueFamilyIndex", 1); + + print_uint32_t(obj.counterIndexCount, "counterIndexCount", 1); + + PRINT_SPACE + _OUT << "\"pCounterIndices\":" << std::endl; + PRINT_SPACE + if (obj.pCounterIndices) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.counterIndexCount; i++) { + bool isCommaNeeded = (i+1) != obj.counterIndexCount; + print_uint32_t(obj.pCounterIndices[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkQueryPoolPerformanceCreateInfoKHR(const VkQueryPoolPerformanceCreateInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->queueFamilyIndex, "queueFamilyIndex", 1); + + print_uint32_t(obj->counterIndexCount, "counterIndexCount", 1); + + PRINT_SPACE + _OUT << "\"pCounterIndices\":" << std::endl; + PRINT_SPACE + if (obj->pCounterIndices) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->counterIndexCount; i++) { + bool isCommaNeeded = (i+1) != obj->counterIndexCount; + print_uint32_t(obj->pCounterIndices[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPerformanceCounterResultKHR(VkPerformanceCounterResultKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_int32_t(obj.int32, "int32", 1); + + print_int64_t(obj.int64, "int64", 1); + + print_uint32_t(obj.uint32, "uint32", 1); + + print_uint64_t(obj.uint64, "uint64", 1); + + print_float(obj.float32, "float32", 1); + + print_double(obj.float64, "float64", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPerformanceCounterResultKHR(const VkPerformanceCounterResultKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_int32_t(obj->int32, "int32", 1); + + print_int64_t(obj->int64, "int64", 1); + + print_uint32_t(obj->uint32, "uint32", 1); + + print_uint64_t(obj->uint64, "uint64", 1); + + print_float(obj->float32, "float32", 1); + + print_double(obj->float64, "float64", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkAcquireProfilingLockInfoKHR(VkAcquireProfilingLockInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkAcquireProfilingLockFlagsKHR(obj.flags, "flags", 1); + + print_uint64_t(obj.timeout, "timeout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkAcquireProfilingLockInfoKHR(const VkAcquireProfilingLockInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkAcquireProfilingLockFlagsKHR(obj->flags, "flags", 1); + + print_uint64_t(obj->timeout, "timeout", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPerformanceQuerySubmitInfoKHR(VkPerformanceQuerySubmitInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.counterPassIndex, "counterPassIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPerformanceQuerySubmitInfoKHR(const VkPerformanceQuerySubmitInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->counterPassIndex, "counterPassIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPerformanceQueryReservationInfoKHR(VkPerformanceQueryReservationInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.maxPerformanceQueriesPerPool, "maxPerformanceQueriesPerPool", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPerformanceQueryReservationInfoKHR(const VkPerformanceQueryReservationInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->maxPerformanceQueriesPerPool, "maxPerformanceQueriesPerPool", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceSurfaceInfo2KHR(VkPhysicalDeviceSurfaceInfo2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "surface" << "\"" << " : " << "\"" << "\"" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "surface" << "\"" << " : " << "\"" << "\"" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSurfaceCapabilities2KHR(VkSurfaceCapabilities2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"surfaceCapabilities\": " << std::endl; + { + print_VkSurfaceCapabilitiesKHR(obj.surfaceCapabilities, "surfaceCapabilities", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"surfaceCapabilities\": " << std::endl; + { + print_VkSurfaceCapabilitiesKHR(obj->surfaceCapabilities, "surfaceCapabilities", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSurfaceFormat2KHR(VkSurfaceFormat2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"surfaceFormat\": " << std::endl; + { + print_VkSurfaceFormatKHR(obj.surfaceFormat, "surfaceFormat", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"surfaceFormat\": " << std::endl; + { + print_VkSurfaceFormatKHR(obj->surfaceFormat, "surfaceFormat", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDisplayProperties2KHR(VkDisplayProperties2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"displayProperties\": " << std::endl; + { + print_VkDisplayPropertiesKHR(obj.displayProperties, "displayProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDisplayProperties2KHR(const VkDisplayProperties2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"displayProperties\": " << std::endl; + { + print_VkDisplayPropertiesKHR(obj->displayProperties, "displayProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDisplayPlaneProperties2KHR(VkDisplayPlaneProperties2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"displayPlaneProperties\": " << std::endl; + { + print_VkDisplayPlanePropertiesKHR(obj.displayPlaneProperties, "displayPlaneProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"displayPlaneProperties\": " << std::endl; + { + print_VkDisplayPlanePropertiesKHR(obj->displayPlaneProperties, "displayPlaneProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDisplayModeProperties2KHR(VkDisplayModeProperties2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"displayModeProperties\": " << std::endl; + { + print_VkDisplayModePropertiesKHR(obj.displayModeProperties, "displayModeProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"displayModeProperties\": " << std::endl; + { + print_VkDisplayModePropertiesKHR(obj->displayModeProperties, "displayModeProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDisplayPlaneInfo2KHR(VkDisplayPlaneInfo2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "mode" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj.planeIndex, "planeIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "mode" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj->planeIndex, "planeIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDisplayPlaneCapabilities2KHR(VkDisplayPlaneCapabilities2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"capabilities\": " << std::endl; + { + print_VkDisplayPlaneCapabilitiesKHR(obj.capabilities, "capabilities", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"capabilities\": " << std::endl; + { + print_VkDisplayPlaneCapabilitiesKHR(obj->capabilities, "capabilities", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceShaderClockFeaturesKHR(VkPhysicalDeviceShaderClockFeaturesKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.shaderSubgroupClock, "shaderSubgroupClock", 1); + + print_VkBool32(obj.shaderDeviceClock, "shaderDeviceClock", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceShaderClockFeaturesKHR(const VkPhysicalDeviceShaderClockFeaturesKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->shaderSubgroupClock, "shaderSubgroupClock", 1); + + print_VkBool32(obj->shaderDeviceClock, "shaderDeviceClock", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.shaderTerminateInvocation, "shaderTerminateInvocation", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->shaderTerminateInvocation, "shaderTerminateInvocation", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static std::map VkFragmentShadingRateCombinerOpKHR_map = { + std::make_pair(0, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR"), + std::make_pair(1, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR"), + std::make_pair(2, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR"), + std::make_pair(3, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR"), + std::make_pair(4, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR"), +}; +static void print_VkFragmentShadingRateCombinerOpKHR(VkFragmentShadingRateCombinerOpKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFragmentShadingRateCombinerOpKHR_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFragmentShadingRateCombinerOpKHR_map[obj] << "\"" << std::endl; +} +static void print_VkFragmentShadingRateCombinerOpKHR(const VkFragmentShadingRateCombinerOpKHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFragmentShadingRateCombinerOpKHR_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFragmentShadingRateCombinerOpKHR_map[*obj] << "\"" << std::endl; +} + +static void print_VkFragmentShadingRateAttachmentInfoKHR(VkFragmentShadingRateAttachmentInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pFragmentShadingRateAttachment\": " << std::endl; + if (obj.pFragmentShadingRateAttachment) { + print_VkAttachmentReference2(obj.pFragmentShadingRateAttachment, "pFragmentShadingRateAttachment", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"shadingRateAttachmentTexelSize\": " << std::endl; + { + print_VkExtent2D(obj.shadingRateAttachmentTexelSize, "shadingRateAttachmentTexelSize", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkFragmentShadingRateAttachmentInfoKHR(const VkFragmentShadingRateAttachmentInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"pFragmentShadingRateAttachment\": " << std::endl; + if (obj->pFragmentShadingRateAttachment) { + print_VkAttachmentReference2(obj->pFragmentShadingRateAttachment, "pFragmentShadingRateAttachment", 1); + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"shadingRateAttachmentTexelSize\": " << std::endl; + { + print_VkExtent2D(obj->shadingRateAttachmentTexelSize, "shadingRateAttachmentTexelSize", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineFragmentShadingRateStateCreateInfoKHR(VkPipelineFragmentShadingRateStateCreateInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"fragmentSize\": " << std::endl; + { + print_VkExtent2D(obj.fragmentSize, "fragmentSize", 1); + } + + PRINT_SPACE + _OUT << "\"combinerOps\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 2; i++) { + bool isCommaNeeded = (i+1) != 2; + print_VkFragmentShadingRateCombinerOpKHR(obj.combinerOps[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineFragmentShadingRateStateCreateInfoKHR(const VkPipelineFragmentShadingRateStateCreateInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"fragmentSize\": " << std::endl; + { + print_VkExtent2D(obj->fragmentSize, "fragmentSize", 1); + } + + PRINT_SPACE + _OUT << "\"combinerOps\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 2; i++) { + bool isCommaNeeded = (i+1) != 2; + print_VkFragmentShadingRateCombinerOpKHR(obj->combinerOps[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(VkPhysicalDeviceFragmentShadingRateFeaturesKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.pipelineFragmentShadingRate, "pipelineFragmentShadingRate", 1); + + print_VkBool32(obj.primitiveFragmentShadingRate, "primitiveFragmentShadingRate", 1); + + print_VkBool32(obj.attachmentFragmentShadingRate, "attachmentFragmentShadingRate", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->pipelineFragmentShadingRate, "pipelineFragmentShadingRate", 1); + + print_VkBool32(obj->primitiveFragmentShadingRate, "primitiveFragmentShadingRate", 1); + + print_VkBool32(obj->attachmentFragmentShadingRate, "attachmentFragmentShadingRate", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(VkPhysicalDeviceFragmentShadingRatePropertiesKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"minFragmentShadingRateAttachmentTexelSize\": " << std::endl; + { + print_VkExtent2D(obj.minFragmentShadingRateAttachmentTexelSize, "minFragmentShadingRateAttachmentTexelSize", 1); + } + + PRINT_SPACE + _OUT << "\"maxFragmentShadingRateAttachmentTexelSize\": " << std::endl; + { + print_VkExtent2D(obj.maxFragmentShadingRateAttachmentTexelSize, "maxFragmentShadingRateAttachmentTexelSize", 1); + } + + print_uint32_t(obj.maxFragmentShadingRateAttachmentTexelSizeAspectRatio, "maxFragmentShadingRateAttachmentTexelSizeAspectRatio", 1); + + print_VkBool32(obj.primitiveFragmentShadingRateWithMultipleViewports, "primitiveFragmentShadingRateWithMultipleViewports", 1); + + print_VkBool32(obj.layeredShadingRateAttachments, "layeredShadingRateAttachments", 1); + + print_VkBool32(obj.fragmentShadingRateNonTrivialCombinerOps, "fragmentShadingRateNonTrivialCombinerOps", 1); + + PRINT_SPACE + _OUT << "\"maxFragmentSize\": " << std::endl; + { + print_VkExtent2D(obj.maxFragmentSize, "maxFragmentSize", 1); + } + + print_uint32_t(obj.maxFragmentSizeAspectRatio, "maxFragmentSizeAspectRatio", 1); + + print_uint32_t(obj.maxFragmentShadingRateCoverageSamples, "maxFragmentShadingRateCoverageSamples", 1); + + print_VkSampleCountFlagBits(obj.maxFragmentShadingRateRasterizationSamples, "maxFragmentShadingRateRasterizationSamples", 1); + + print_VkBool32(obj.fragmentShadingRateWithShaderDepthStencilWrites, "fragmentShadingRateWithShaderDepthStencilWrites", 1); + + print_VkBool32(obj.fragmentShadingRateWithSampleMask, "fragmentShadingRateWithSampleMask", 1); + + print_VkBool32(obj.fragmentShadingRateWithShaderSampleMask, "fragmentShadingRateWithShaderSampleMask", 1); + + print_VkBool32(obj.fragmentShadingRateWithConservativeRasterization, "fragmentShadingRateWithConservativeRasterization", 1); + + print_VkBool32(obj.fragmentShadingRateWithFragmentShaderInterlock, "fragmentShadingRateWithFragmentShaderInterlock", 1); + + print_VkBool32(obj.fragmentShadingRateWithCustomSampleLocations, "fragmentShadingRateWithCustomSampleLocations", 1); + + print_VkBool32(obj.fragmentShadingRateStrictMultiplyCombiner, "fragmentShadingRateStrictMultiplyCombiner", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"minFragmentShadingRateAttachmentTexelSize\": " << std::endl; + { + print_VkExtent2D(obj->minFragmentShadingRateAttachmentTexelSize, "minFragmentShadingRateAttachmentTexelSize", 1); + } + + PRINT_SPACE + _OUT << "\"maxFragmentShadingRateAttachmentTexelSize\": " << std::endl; + { + print_VkExtent2D(obj->maxFragmentShadingRateAttachmentTexelSize, "maxFragmentShadingRateAttachmentTexelSize", 1); + } + + print_uint32_t(obj->maxFragmentShadingRateAttachmentTexelSizeAspectRatio, "maxFragmentShadingRateAttachmentTexelSizeAspectRatio", 1); + + print_VkBool32(obj->primitiveFragmentShadingRateWithMultipleViewports, "primitiveFragmentShadingRateWithMultipleViewports", 1); + + print_VkBool32(obj->layeredShadingRateAttachments, "layeredShadingRateAttachments", 1); + + print_VkBool32(obj->fragmentShadingRateNonTrivialCombinerOps, "fragmentShadingRateNonTrivialCombinerOps", 1); + + PRINT_SPACE + _OUT << "\"maxFragmentSize\": " << std::endl; + { + print_VkExtent2D(obj->maxFragmentSize, "maxFragmentSize", 1); + } + + print_uint32_t(obj->maxFragmentSizeAspectRatio, "maxFragmentSizeAspectRatio", 1); + + print_uint32_t(obj->maxFragmentShadingRateCoverageSamples, "maxFragmentShadingRateCoverageSamples", 1); + + print_VkSampleCountFlagBits(obj->maxFragmentShadingRateRasterizationSamples, "maxFragmentShadingRateRasterizationSamples", 1); + + print_VkBool32(obj->fragmentShadingRateWithShaderDepthStencilWrites, "fragmentShadingRateWithShaderDepthStencilWrites", 1); + + print_VkBool32(obj->fragmentShadingRateWithSampleMask, "fragmentShadingRateWithSampleMask", 1); + + print_VkBool32(obj->fragmentShadingRateWithShaderSampleMask, "fragmentShadingRateWithShaderSampleMask", 1); + + print_VkBool32(obj->fragmentShadingRateWithConservativeRasterization, "fragmentShadingRateWithConservativeRasterization", 1); + + print_VkBool32(obj->fragmentShadingRateWithFragmentShaderInterlock, "fragmentShadingRateWithFragmentShaderInterlock", 1); + + print_VkBool32(obj->fragmentShadingRateWithCustomSampleLocations, "fragmentShadingRateWithCustomSampleLocations", 1); + + print_VkBool32(obj->fragmentShadingRateStrictMultiplyCombiner, "fragmentShadingRateStrictMultiplyCombiner", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceFragmentShadingRateKHR(VkPhysicalDeviceFragmentShadingRateKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSampleCountFlags(obj.sampleCounts, "sampleCounts", 1); + + PRINT_SPACE + _OUT << "\"fragmentSize\": " << std::endl; + { + print_VkExtent2D(obj.fragmentSize, "fragmentSize", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceFragmentShadingRateKHR(const VkPhysicalDeviceFragmentShadingRateKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSampleCountFlags(obj->sampleCounts, "sampleCounts", 1); + + PRINT_SPACE + _OUT << "\"fragmentSize\": " << std::endl; + { + print_VkExtent2D(obj->fragmentSize, "fragmentSize", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static std::map VkRefreshObjectFlagBitsKHR_map = { +}; +static void print_VkRefreshObjectFlagBitsKHR(VkRefreshObjectFlagBitsKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkRefreshObjectFlagBitsKHR_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkRefreshObjectFlagBitsKHR_map[obj] << "\"" << std::endl; +} +static void print_VkRefreshObjectFlagBitsKHR(const VkRefreshObjectFlagBitsKHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkRefreshObjectFlagBitsKHR_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkRefreshObjectFlagBitsKHR_map[*obj] << "\"" << std::endl; +} + +static void print_VkRefreshObjectFlagsKHR(VkRefreshObjectFlagsKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + const int max_bits = 64; // We don't expect the number to be larger. + std::bitset b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkRefreshObjectFlagBitsKHR_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkRefreshObjectFlagBitsKHR_map[1ULL<objectType, "objectType", 1); + + print_uint64_t(obj->objectHandle, "objectHandle", 1); + + print_VkRefreshObjectFlagsKHR(obj->flags, "flags", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkRefreshObjectListKHR(VkRefreshObjectListKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.objectCount, "objectCount", 1); + + PRINT_SPACE + _OUT << "\"pObjects\": " << std::endl; + if (obj.pObjects) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.objectCount; i++) { + if (i+1 == obj.objectCount) + print_VkRefreshObjectKHR(obj.pObjects[i], "pObjects", 0); + else + print_VkRefreshObjectKHR(obj.pObjects[i], "pObjects", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkRefreshObjectListKHR(const VkRefreshObjectListKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->objectCount, "objectCount", 1); + + PRINT_SPACE + _OUT << "\"pObjects\": " << std::endl; + if (obj->pObjects) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->objectCount; i++) { + if (i+1 == obj->objectCount) + print_VkRefreshObjectKHR(obj->pObjects[i], "pObjects", 0); + else + print_VkRefreshObjectKHR(obj->pObjects[i], "pObjects", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkFlags64(VkFlags64 obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl; +} +static void print_VkFlags64(const VkFlags64 * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "\"" << str << "\"" << " : " << "\"" << obj << "\"" << (commaNeeded ? "," : "") << std::endl; +} + +static std::map VkPipelineStageFlagBits2KHR_map = { + std::make_pair(0, "VK_PIPELINE_STAGE_2_NONE_KHR"), + std::make_pair(1ULL << 0, "VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR"), + std::make_pair(1ULL << 1, "VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR"), + std::make_pair(1ULL << 2, "VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR"), + std::make_pair(1ULL << 3, "VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR"), + std::make_pair(1ULL << 4, "VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR"), + std::make_pair(1ULL << 5, "VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR"), + std::make_pair(1ULL << 6, "VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR"), + std::make_pair(1ULL << 7, "VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR"), + std::make_pair(1ULL << 8, "VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR"), + std::make_pair(1ULL << 9, "VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR"), + std::make_pair(1ULL << 10, "VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR"), + std::make_pair(1ULL << 11, "VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR"), + std::make_pair(1ULL << 12, "VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR"), + std::make_pair(1ULL << 13, "VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR"), + std::make_pair(1ULL << 14, "VK_PIPELINE_STAGE_2_HOST_BIT_KHR"), + std::make_pair(1ULL << 15, "VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR"), + std::make_pair(1ULL << 16, "VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR"), + std::make_pair(1ULL << 32, "VK_PIPELINE_STAGE_2_COPY_BIT_KHR"), + std::make_pair(1ULL << 33, "VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR"), + std::make_pair(1ULL << 34, "VK_PIPELINE_STAGE_2_BLIT_BIT_KHR"), + std::make_pair(1ULL << 35, "VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR"), + std::make_pair(1ULL << 36, "VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR"), + std::make_pair(1ULL << 37, "VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR"), + std::make_pair(1ULL << 38, "VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR"), + std::make_pair(1ULL << 26, "VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR"), + std::make_pair(1ULL << 27, "VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR"), + std::make_pair(1ULL << 24, "VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT"), + std::make_pair(1ULL << 18, "VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT"), + std::make_pair(1ULL << 17, "VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV"), + std::make_pair(1ULL << 22, "VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"), + std::make_pair(1ULL << 25, "VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR"), + std::make_pair(1ULL << 21, "VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR"), + std::make_pair(1ULL << 23, "VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT"), + std::make_pair(1ULL << 19, "VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV"), + std::make_pair(1ULL << 20, "VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV"), + std::make_pair(1ULL << 39, "VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI"), + std::make_pair(1ULL << 40, "VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI"), + std::make_pair(1ULL << 28, "VK_PIPELINE_STAGE_2_RESERVED_387_BIT_KHR"), +}; +static void print_VkPipelineStageFlagBits2KHR(VkPipelineStageFlagBits2KHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPipelineStageFlagBits2KHR_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPipelineStageFlagBits2KHR_map[obj] << "\"" << std::endl; +} +static void print_VkPipelineStageFlagBits2KHR(const VkPipelineStageFlagBits2KHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkPipelineStageFlagBits2KHR_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkPipelineStageFlagBits2KHR_map[*obj] << "\"" << std::endl; +} + +static std::map VkAccessFlagBits2KHR_map = { + std::make_pair(0, "VK_ACCESS_2_NONE_KHR"), + std::make_pair(1ULL << 0, "VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR"), + std::make_pair(1ULL << 1, "VK_ACCESS_2_INDEX_READ_BIT_KHR"), + std::make_pair(1ULL << 2, "VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR"), + std::make_pair(1ULL << 3, "VK_ACCESS_2_UNIFORM_READ_BIT_KHR"), + std::make_pair(1ULL << 4, "VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR"), + std::make_pair(1ULL << 5, "VK_ACCESS_2_SHADER_READ_BIT_KHR"), + std::make_pair(1ULL << 6, "VK_ACCESS_2_SHADER_WRITE_BIT_KHR"), + std::make_pair(1ULL << 7, "VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR"), + std::make_pair(1ULL << 8, "VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR"), + std::make_pair(1ULL << 9, "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR"), + std::make_pair(1ULL << 10, "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR"), + std::make_pair(1ULL << 11, "VK_ACCESS_2_TRANSFER_READ_BIT_KHR"), + std::make_pair(1ULL << 12, "VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR"), + std::make_pair(1ULL << 13, "VK_ACCESS_2_HOST_READ_BIT_KHR"), + std::make_pair(1ULL << 14, "VK_ACCESS_2_HOST_WRITE_BIT_KHR"), + std::make_pair(1ULL << 15, "VK_ACCESS_2_MEMORY_READ_BIT_KHR"), + std::make_pair(1ULL << 16, "VK_ACCESS_2_MEMORY_WRITE_BIT_KHR"), + std::make_pair(1ULL << 32, "VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR"), + std::make_pair(1ULL << 33, "VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR"), + std::make_pair(1ULL << 34, "VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR"), + std::make_pair(1ULL << 35, "VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR"), + std::make_pair(1ULL << 36, "VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR"), + std::make_pair(1ULL << 37, "VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR"), + std::make_pair(1ULL << 38, "VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR"), + std::make_pair(1ULL << 25, "VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT"), + std::make_pair(1ULL << 26, "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT"), + std::make_pair(1ULL << 27, "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT"), + std::make_pair(1ULL << 20, "VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT"), + std::make_pair(1ULL << 17, "VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV"), + std::make_pair(1ULL << 18, "VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV"), + std::make_pair(1ULL << 23, "VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR"), + std::make_pair(1ULL << 21, "VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR"), + std::make_pair(1ULL << 22, "VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR"), + std::make_pair(1ULL << 24, "VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT"), + std::make_pair(1ULL << 19, "VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT"), + std::make_pair(1ULL << 41, "VK_ACCESS_2_RESERVED_41_BIT_AMD"), + std::make_pair(1ULL << 39, "VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI"), + std::make_pair(1ULL << 40, "VK_ACCESS_2_RESERVED_387_BIT_KHR"), +}; +static void print_VkAccessFlagBits2KHR(VkAccessFlagBits2KHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkAccessFlagBits2KHR_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkAccessFlagBits2KHR_map[obj] << "\"" << std::endl; +} +static void print_VkAccessFlagBits2KHR(const VkAccessFlagBits2KHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkAccessFlagBits2KHR_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkAccessFlagBits2KHR_map[*obj] << "\"" << std::endl; +} + +static std::map VkSubmitFlagBitsKHR_map = { + std::make_pair(1ULL << 0, "VK_SUBMIT_PROTECTED_BIT_KHR"), +}; +static void print_VkSubmitFlagBitsKHR(VkSubmitFlagBitsKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSubmitFlagBitsKHR_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSubmitFlagBitsKHR_map[obj] << "\"" << std::endl; +} +static void print_VkSubmitFlagBitsKHR(const VkSubmitFlagBitsKHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSubmitFlagBitsKHR_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSubmitFlagBitsKHR_map[*obj] << "\"" << std::endl; +} + +static void print_VkPipelineStageFlags2KHR(VkPipelineStageFlags2KHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl; + else + _OUT << "\"" << str << "\"" << " : " << obj << std::endl; +} +static void print_VkPipelineStageFlags2KHR(const VkPipelineStageFlags2KHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl; + else + _OUT << "\"" << str << "\"" << " : " << obj << std::endl; +} + +static void print_VkAccessFlags2KHR(VkAccessFlags2KHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl; + else + _OUT << "\"" << str << "\"" << " : " << obj << std::endl; +} +static void print_VkAccessFlags2KHR(const VkAccessFlags2KHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl; + else + _OUT << "\"" << str << "\"" << " : " << obj << std::endl; +} + +static void print_VkSubmitFlagsKHR(VkSubmitFlagsKHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + const int max_bits = 64; // We don't expect the number to be larger. + std::bitset b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkSubmitFlagBitsKHR_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkSubmitFlagBitsKHR_map[1ULL<sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineStageFlags2KHR(obj->srcStageMask, "srcStageMask", 1); + + print_VkAccessFlags2KHR(obj->srcAccessMask, "srcAccessMask", 1); + + print_VkPipelineStageFlags2KHR(obj->dstStageMask, "dstStageMask", 1); + + print_VkAccessFlags2KHR(obj->dstAccessMask, "dstAccessMask", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkBufferMemoryBarrier2KHR(VkBufferMemoryBarrier2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineStageFlags2KHR(obj.srcStageMask, "srcStageMask", 1); + + print_VkAccessFlags2KHR(obj.srcAccessMask, "srcAccessMask", 1); + + print_VkPipelineStageFlags2KHR(obj.dstStageMask, "dstStageMask", 1); + + print_VkAccessFlags2KHR(obj.dstAccessMask, "dstAccessMask", 1); + + print_uint32_t(obj.srcQueueFamilyIndex, "srcQueueFamilyIndex", 1); + + print_uint32_t(obj.dstQueueFamilyIndex, "dstQueueFamilyIndex", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkDeviceSize(obj.offset, "offset", 1); + + print_VkDeviceSize(obj.size, "size", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkBufferMemoryBarrier2KHR(const VkBufferMemoryBarrier2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineStageFlags2KHR(obj->srcStageMask, "srcStageMask", 1); + + print_VkAccessFlags2KHR(obj->srcAccessMask, "srcAccessMask", 1); + + print_VkPipelineStageFlags2KHR(obj->dstStageMask, "dstStageMask", 1); + + print_VkAccessFlags2KHR(obj->dstAccessMask, "dstAccessMask", 1); + + print_uint32_t(obj->srcQueueFamilyIndex, "srcQueueFamilyIndex", 1); + + print_uint32_t(obj->dstQueueFamilyIndex, "dstQueueFamilyIndex", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "buffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkDeviceSize(obj->offset, "offset", 1); + + print_VkDeviceSize(obj->size, "size", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageMemoryBarrier2KHR(VkImageMemoryBarrier2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineStageFlags2KHR(obj.srcStageMask, "srcStageMask", 1); + + print_VkAccessFlags2KHR(obj.srcAccessMask, "srcAccessMask", 1); + + print_VkPipelineStageFlags2KHR(obj.dstStageMask, "dstStageMask", 1); + + print_VkAccessFlags2KHR(obj.dstAccessMask, "dstAccessMask", 1); + + print_VkImageLayout(obj.oldLayout, "oldLayout", 1); + + print_VkImageLayout(obj.newLayout, "newLayout", 1); + + print_uint32_t(obj.srcQueueFamilyIndex, "srcQueueFamilyIndex", 1); + + print_uint32_t(obj.dstQueueFamilyIndex, "dstQueueFamilyIndex", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"," << std::endl; + + PRINT_SPACE + _OUT << "\"subresourceRange\": " << std::endl; + { + print_VkImageSubresourceRange(obj.subresourceRange, "subresourceRange", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageMemoryBarrier2KHR(const VkImageMemoryBarrier2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineStageFlags2KHR(obj->srcStageMask, "srcStageMask", 1); + + print_VkAccessFlags2KHR(obj->srcAccessMask, "srcAccessMask", 1); + + print_VkPipelineStageFlags2KHR(obj->dstStageMask, "dstStageMask", 1); + + print_VkAccessFlags2KHR(obj->dstAccessMask, "dstAccessMask", 1); + + print_VkImageLayout(obj->oldLayout, "oldLayout", 1); + + print_VkImageLayout(obj->newLayout, "newLayout", 1); + + print_uint32_t(obj->srcQueueFamilyIndex, "srcQueueFamilyIndex", 1); + + print_uint32_t(obj->dstQueueFamilyIndex, "dstQueueFamilyIndex", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "image" << "\"" << " : " << "\"" << "\"," << std::endl; + + PRINT_SPACE + _OUT << "\"subresourceRange\": " << std::endl; + { + print_VkImageSubresourceRange(obj->subresourceRange, "subresourceRange", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDependencyInfoKHR(VkDependencyInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDependencyFlags(obj.dependencyFlags, "dependencyFlags", 1); + + print_uint32_t(obj.memoryBarrierCount, "memoryBarrierCount", 1); + + PRINT_SPACE + _OUT << "\"pMemoryBarriers\": " << std::endl; + if (obj.pMemoryBarriers) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.memoryBarrierCount; i++) { + if (i+1 == obj.memoryBarrierCount) + print_VkMemoryBarrier2KHR(obj.pMemoryBarriers[i], "pMemoryBarriers", 0); + else + print_VkMemoryBarrier2KHR(obj.pMemoryBarriers[i], "pMemoryBarriers", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.bufferMemoryBarrierCount, "bufferMemoryBarrierCount", 1); + + PRINT_SPACE + _OUT << "\"pBufferMemoryBarriers\": " << std::endl; + if (obj.pBufferMemoryBarriers) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.bufferMemoryBarrierCount; i++) { + if (i+1 == obj.bufferMemoryBarrierCount) + print_VkBufferMemoryBarrier2KHR(obj.pBufferMemoryBarriers[i], "pBufferMemoryBarriers", 0); + else + print_VkBufferMemoryBarrier2KHR(obj.pBufferMemoryBarriers[i], "pBufferMemoryBarriers", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.imageMemoryBarrierCount, "imageMemoryBarrierCount", 1); + + PRINT_SPACE + _OUT << "\"pImageMemoryBarriers\": " << std::endl; + if (obj.pImageMemoryBarriers) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.imageMemoryBarrierCount; i++) { + if (i+1 == obj.imageMemoryBarrierCount) + print_VkImageMemoryBarrier2KHR(obj.pImageMemoryBarriers[i], "pImageMemoryBarriers", 0); + else + print_VkImageMemoryBarrier2KHR(obj.pImageMemoryBarriers[i], "pImageMemoryBarriers", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDependencyInfoKHR(const VkDependencyInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDependencyFlags(obj->dependencyFlags, "dependencyFlags", 1); + + print_uint32_t(obj->memoryBarrierCount, "memoryBarrierCount", 1); + + PRINT_SPACE + _OUT << "\"pMemoryBarriers\": " << std::endl; + if (obj->pMemoryBarriers) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->memoryBarrierCount; i++) { + if (i+1 == obj->memoryBarrierCount) + print_VkMemoryBarrier2KHR(obj->pMemoryBarriers[i], "pMemoryBarriers", 0); + else + print_VkMemoryBarrier2KHR(obj->pMemoryBarriers[i], "pMemoryBarriers", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->bufferMemoryBarrierCount, "bufferMemoryBarrierCount", 1); + + PRINT_SPACE + _OUT << "\"pBufferMemoryBarriers\": " << std::endl; + if (obj->pBufferMemoryBarriers) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->bufferMemoryBarrierCount; i++) { + if (i+1 == obj->bufferMemoryBarrierCount) + print_VkBufferMemoryBarrier2KHR(obj->pBufferMemoryBarriers[i], "pBufferMemoryBarriers", 0); + else + print_VkBufferMemoryBarrier2KHR(obj->pBufferMemoryBarriers[i], "pBufferMemoryBarriers", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->imageMemoryBarrierCount, "imageMemoryBarrierCount", 1); + + PRINT_SPACE + _OUT << "\"pImageMemoryBarriers\": " << std::endl; + if (obj->pImageMemoryBarriers) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->imageMemoryBarrierCount; i++) { + if (i+1 == obj->imageMemoryBarrierCount) + print_VkImageMemoryBarrier2KHR(obj->pImageMemoryBarriers[i], "pImageMemoryBarriers", 0); + else + print_VkImageMemoryBarrier2KHR(obj->pImageMemoryBarriers[i], "pImageMemoryBarriers", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSemaphoreSubmitInfoKHR(VkSemaphoreSubmitInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "semaphore" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint64_t(obj.value, "value", 1); + + print_VkPipelineStageFlags2KHR(obj.stageMask, "stageMask", 1); + + print_uint32_t(obj.deviceIndex, "deviceIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSemaphoreSubmitInfoKHR(const VkSemaphoreSubmitInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "semaphore" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint64_t(obj->value, "value", 1); + + print_VkPipelineStageFlags2KHR(obj->stageMask, "stageMask", 1); + + print_uint32_t(obj->deviceIndex, "deviceIndex", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkCommandBufferSubmitInfoKHR(VkCommandBufferSubmitInfoKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "commandBuffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj.deviceMask, "deviceMask", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkCommandBufferSubmitInfoKHR(const VkCommandBufferSubmitInfoKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "commandBuffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj->deviceMask, "deviceMask", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSubmitInfo2KHR(VkSubmitInfo2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSubmitFlagsKHR(obj.flags, "flags", 1); + + print_uint32_t(obj.waitSemaphoreInfoCount, "waitSemaphoreInfoCount", 1); + + PRINT_SPACE + _OUT << "\"pWaitSemaphoreInfos\": " << std::endl; + if (obj.pWaitSemaphoreInfos) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.waitSemaphoreInfoCount; i++) { + if (i+1 == obj.waitSemaphoreInfoCount) + print_VkSemaphoreSubmitInfoKHR(obj.pWaitSemaphoreInfos[i], "pWaitSemaphoreInfos", 0); + else + print_VkSemaphoreSubmitInfoKHR(obj.pWaitSemaphoreInfos[i], "pWaitSemaphoreInfos", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.commandBufferInfoCount, "commandBufferInfoCount", 1); + + PRINT_SPACE + _OUT << "\"pCommandBufferInfos\": " << std::endl; + if (obj.pCommandBufferInfos) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.commandBufferInfoCount; i++) { + if (i+1 == obj.commandBufferInfoCount) + print_VkCommandBufferSubmitInfoKHR(obj.pCommandBufferInfos[i], "pCommandBufferInfos", 0); + else + print_VkCommandBufferSubmitInfoKHR(obj.pCommandBufferInfos[i], "pCommandBufferInfos", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.signalSemaphoreInfoCount, "signalSemaphoreInfoCount", 1); + + PRINT_SPACE + _OUT << "\"pSignalSemaphoreInfos\": " << std::endl; + if (obj.pSignalSemaphoreInfos) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.signalSemaphoreInfoCount; i++) { + if (i+1 == obj.signalSemaphoreInfoCount) + print_VkSemaphoreSubmitInfoKHR(obj.pSignalSemaphoreInfos[i], "pSignalSemaphoreInfos", 0); + else + print_VkSemaphoreSubmitInfoKHR(obj.pSignalSemaphoreInfos[i], "pSignalSemaphoreInfos", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSubmitInfo2KHR(const VkSubmitInfo2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSubmitFlagsKHR(obj->flags, "flags", 1); + + print_uint32_t(obj->waitSemaphoreInfoCount, "waitSemaphoreInfoCount", 1); + + PRINT_SPACE + _OUT << "\"pWaitSemaphoreInfos\": " << std::endl; + if (obj->pWaitSemaphoreInfos) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->waitSemaphoreInfoCount; i++) { + if (i+1 == obj->waitSemaphoreInfoCount) + print_VkSemaphoreSubmitInfoKHR(obj->pWaitSemaphoreInfos[i], "pWaitSemaphoreInfos", 0); + else + print_VkSemaphoreSubmitInfoKHR(obj->pWaitSemaphoreInfos[i], "pWaitSemaphoreInfos", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->commandBufferInfoCount, "commandBufferInfoCount", 1); + + PRINT_SPACE + _OUT << "\"pCommandBufferInfos\": " << std::endl; + if (obj->pCommandBufferInfos) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->commandBufferInfoCount; i++) { + if (i+1 == obj->commandBufferInfoCount) + print_VkCommandBufferSubmitInfoKHR(obj->pCommandBufferInfos[i], "pCommandBufferInfos", 0); + else + print_VkCommandBufferSubmitInfoKHR(obj->pCommandBufferInfos[i], "pCommandBufferInfos", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->signalSemaphoreInfoCount, "signalSemaphoreInfoCount", 1); + + PRINT_SPACE + _OUT << "\"pSignalSemaphoreInfos\": " << std::endl; + if (obj->pSignalSemaphoreInfos) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->signalSemaphoreInfoCount; i++) { + if (i+1 == obj->signalSemaphoreInfoCount) + print_VkSemaphoreSubmitInfoKHR(obj->pSignalSemaphoreInfos[i], "pSignalSemaphoreInfos", 0); + else + print_VkSemaphoreSubmitInfoKHR(obj->pSignalSemaphoreInfos[i], "pSignalSemaphoreInfos", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceSynchronization2FeaturesKHR(VkPhysicalDeviceSynchronization2FeaturesKHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.synchronization2, "synchronization2", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceSynchronization2FeaturesKHR(const VkPhysicalDeviceSynchronization2FeaturesKHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->synchronization2, "synchronization2", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkQueueFamilyCheckpointProperties2NV(VkQueueFamilyCheckpointProperties2NV obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineStageFlags2KHR(obj.checkpointExecutionStageMask, "checkpointExecutionStageMask", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkQueueFamilyCheckpointProperties2NV(const VkQueueFamilyCheckpointProperties2NV * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineStageFlags2KHR(obj->checkpointExecutionStageMask, "checkpointExecutionStageMask", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkCheckpointData2NV(VkCheckpointData2NV obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineStageFlags2KHR(obj.stage, "stage", 1); + + /** Note: Ignoring void* data. **/ + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkCheckpointData2NV(const VkCheckpointData2NV * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineStageFlags2KHR(obj->stage, "stage", 1); + + /** Note: Ignoring void* data. **/ + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkBufferCopy2KHR(VkBufferCopy2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceSize(obj.srcOffset, "srcOffset", 1); + + print_VkDeviceSize(obj.dstOffset, "dstOffset", 1); + + print_VkDeviceSize(obj.size, "size", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkBufferCopy2KHR(const VkBufferCopy2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceSize(obj->srcOffset, "srcOffset", 1); + + print_VkDeviceSize(obj->dstOffset, "dstOffset", 1); + + print_VkDeviceSize(obj->size, "size", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkCopyBufferInfo2KHR(VkCopyBufferInfo2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "srcBuffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "dstBuffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj.regionCount, "regionCount", 1); + + PRINT_SPACE + _OUT << "\"pRegions\": " << std::endl; + if (obj.pRegions) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.regionCount; i++) { + if (i+1 == obj.regionCount) + print_VkBufferCopy2KHR(obj.pRegions[i], "pRegions", 0); + else + print_VkBufferCopy2KHR(obj.pRegions[i], "pRegions", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkCopyBufferInfo2KHR(const VkCopyBufferInfo2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "srcBuffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "dstBuffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj->regionCount, "regionCount", 1); + + PRINT_SPACE + _OUT << "\"pRegions\": " << std::endl; + if (obj->pRegions) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->regionCount; i++) { + if (i+1 == obj->regionCount) + print_VkBufferCopy2KHR(obj->pRegions[i], "pRegions", 0); + else + print_VkBufferCopy2KHR(obj->pRegions[i], "pRegions", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageCopy2KHR(VkImageCopy2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"srcSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj.srcSubresource, "srcSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"srcOffset\": " << std::endl; + { + print_VkOffset3D(obj.srcOffset, "srcOffset", 1); + } + + PRINT_SPACE + _OUT << "\"dstSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj.dstSubresource, "dstSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"dstOffset\": " << std::endl; + { + print_VkOffset3D(obj.dstOffset, "dstOffset", 1); + } + + PRINT_SPACE + _OUT << "\"extent\": " << std::endl; + { + print_VkExtent3D(obj.extent, "extent", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageCopy2KHR(const VkImageCopy2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"srcSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj->srcSubresource, "srcSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"srcOffset\": " << std::endl; + { + print_VkOffset3D(obj->srcOffset, "srcOffset", 1); + } + + PRINT_SPACE + _OUT << "\"dstSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj->dstSubresource, "dstSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"dstOffset\": " << std::endl; + { + print_VkOffset3D(obj->dstOffset, "dstOffset", 1); + } + + PRINT_SPACE + _OUT << "\"extent\": " << std::endl; + { + print_VkExtent3D(obj->extent, "extent", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkCopyImageInfo2KHR(VkCopyImageInfo2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "srcImage" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkImageLayout(obj.srcImageLayout, "srcImageLayout", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "dstImage" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkImageLayout(obj.dstImageLayout, "dstImageLayout", 1); + + print_uint32_t(obj.regionCount, "regionCount", 1); + + PRINT_SPACE + _OUT << "\"pRegions\": " << std::endl; + if (obj.pRegions) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.regionCount; i++) { + if (i+1 == obj.regionCount) + print_VkImageCopy2KHR(obj.pRegions[i], "pRegions", 0); + else + print_VkImageCopy2KHR(obj.pRegions[i], "pRegions", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkCopyImageInfo2KHR(const VkCopyImageInfo2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "srcImage" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkImageLayout(obj->srcImageLayout, "srcImageLayout", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "dstImage" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkImageLayout(obj->dstImageLayout, "dstImageLayout", 1); + + print_uint32_t(obj->regionCount, "regionCount", 1); + + PRINT_SPACE + _OUT << "\"pRegions\": " << std::endl; + if (obj->pRegions) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->regionCount; i++) { + if (i+1 == obj->regionCount) + print_VkImageCopy2KHR(obj->pRegions[i], "pRegions", 0); + else + print_VkImageCopy2KHR(obj->pRegions[i], "pRegions", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkBufferImageCopy2KHR(VkBufferImageCopy2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceSize(obj.bufferOffset, "bufferOffset", 1); + + print_uint32_t(obj.bufferRowLength, "bufferRowLength", 1); + + print_uint32_t(obj.bufferImageHeight, "bufferImageHeight", 1); + + PRINT_SPACE + _OUT << "\"imageSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj.imageSubresource, "imageSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"imageOffset\": " << std::endl; + { + print_VkOffset3D(obj.imageOffset, "imageOffset", 1); + } + + PRINT_SPACE + _OUT << "\"imageExtent\": " << std::endl; + { + print_VkExtent3D(obj.imageExtent, "imageExtent", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkBufferImageCopy2KHR(const VkBufferImageCopy2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceSize(obj->bufferOffset, "bufferOffset", 1); + + print_uint32_t(obj->bufferRowLength, "bufferRowLength", 1); + + print_uint32_t(obj->bufferImageHeight, "bufferImageHeight", 1); + + PRINT_SPACE + _OUT << "\"imageSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj->imageSubresource, "imageSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"imageOffset\": " << std::endl; + { + print_VkOffset3D(obj->imageOffset, "imageOffset", 1); + } + + PRINT_SPACE + _OUT << "\"imageExtent\": " << std::endl; + { + print_VkExtent3D(obj->imageExtent, "imageExtent", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkCopyBufferToImageInfo2KHR(VkCopyBufferToImageInfo2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "srcBuffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "dstImage" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkImageLayout(obj.dstImageLayout, "dstImageLayout", 1); + + print_uint32_t(obj.regionCount, "regionCount", 1); + + PRINT_SPACE + _OUT << "\"pRegions\": " << std::endl; + if (obj.pRegions) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.regionCount; i++) { + if (i+1 == obj.regionCount) + print_VkBufferImageCopy2KHR(obj.pRegions[i], "pRegions", 0); + else + print_VkBufferImageCopy2KHR(obj.pRegions[i], "pRegions", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkCopyBufferToImageInfo2KHR(const VkCopyBufferToImageInfo2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "srcBuffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "dstImage" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkImageLayout(obj->dstImageLayout, "dstImageLayout", 1); + + print_uint32_t(obj->regionCount, "regionCount", 1); + + PRINT_SPACE + _OUT << "\"pRegions\": " << std::endl; + if (obj->pRegions) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->regionCount; i++) { + if (i+1 == obj->regionCount) + print_VkBufferImageCopy2KHR(obj->pRegions[i], "pRegions", 0); + else + print_VkBufferImageCopy2KHR(obj->pRegions[i], "pRegions", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkCopyImageToBufferInfo2KHR(VkCopyImageToBufferInfo2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "srcImage" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkImageLayout(obj.srcImageLayout, "srcImageLayout", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "dstBuffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj.regionCount, "regionCount", 1); + + PRINT_SPACE + _OUT << "\"pRegions\": " << std::endl; + if (obj.pRegions) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.regionCount; i++) { + if (i+1 == obj.regionCount) + print_VkBufferImageCopy2KHR(obj.pRegions[i], "pRegions", 0); + else + print_VkBufferImageCopy2KHR(obj.pRegions[i], "pRegions", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkCopyImageToBufferInfo2KHR(const VkCopyImageToBufferInfo2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "srcImage" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkImageLayout(obj->srcImageLayout, "srcImageLayout", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "dstBuffer" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_uint32_t(obj->regionCount, "regionCount", 1); + + PRINT_SPACE + _OUT << "\"pRegions\": " << std::endl; + if (obj->pRegions) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->regionCount; i++) { + if (i+1 == obj->regionCount) + print_VkBufferImageCopy2KHR(obj->pRegions[i], "pRegions", 0); + else + print_VkBufferImageCopy2KHR(obj->pRegions[i], "pRegions", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageBlit2KHR(VkImageBlit2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"srcSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj.srcSubresource, "srcSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"srcOffsets\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 2; i++) { + bool isCommaNeeded = (i+1) != 2; + print_VkOffset3D(obj.srcOffsets[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"dstSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj.dstSubresource, "dstSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"dstOffsets\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 2; i++) { + bool isCommaNeeded = (i+1) != 2; + print_VkOffset3D(obj.dstOffsets[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageBlit2KHR(const VkImageBlit2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"srcSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj->srcSubresource, "srcSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"srcOffsets\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 2; i++) { + bool isCommaNeeded = (i+1) != 2; + print_VkOffset3D(obj->srcOffsets[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"dstSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj->dstSubresource, "dstSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"dstOffsets\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 2; i++) { + bool isCommaNeeded = (i+1) != 2; + print_VkOffset3D(obj->dstOffsets[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkBlitImageInfo2KHR(VkBlitImageInfo2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "srcImage" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkImageLayout(obj.srcImageLayout, "srcImageLayout", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "dstImage" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkImageLayout(obj.dstImageLayout, "dstImageLayout", 1); + + print_uint32_t(obj.regionCount, "regionCount", 1); + + PRINT_SPACE + _OUT << "\"pRegions\": " << std::endl; + if (obj.pRegions) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.regionCount; i++) { + if (i+1 == obj.regionCount) + print_VkImageBlit2KHR(obj.pRegions[i], "pRegions", 0); + else + print_VkImageBlit2KHR(obj.pRegions[i], "pRegions", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_VkFilter(obj.filter, "filter", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkBlitImageInfo2KHR(const VkBlitImageInfo2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "srcImage" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkImageLayout(obj->srcImageLayout, "srcImageLayout", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "dstImage" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkImageLayout(obj->dstImageLayout, "dstImageLayout", 1); + + print_uint32_t(obj->regionCount, "regionCount", 1); + + PRINT_SPACE + _OUT << "\"pRegions\": " << std::endl; + if (obj->pRegions) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->regionCount; i++) { + if (i+1 == obj->regionCount) + print_VkImageBlit2KHR(obj->pRegions[i], "pRegions", 0); + else + print_VkImageBlit2KHR(obj->pRegions[i], "pRegions", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_VkFilter(obj->filter, "filter", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageResolve2KHR(VkImageResolve2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"srcSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj.srcSubresource, "srcSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"srcOffset\": " << std::endl; + { + print_VkOffset3D(obj.srcOffset, "srcOffset", 1); + } + + PRINT_SPACE + _OUT << "\"dstSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj.dstSubresource, "dstSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"dstOffset\": " << std::endl; + { + print_VkOffset3D(obj.dstOffset, "dstOffset", 1); + } + + PRINT_SPACE + _OUT << "\"extent\": " << std::endl; + { + print_VkExtent3D(obj.extent, "extent", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageResolve2KHR(const VkImageResolve2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"srcSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj->srcSubresource, "srcSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"srcOffset\": " << std::endl; + { + print_VkOffset3D(obj->srcOffset, "srcOffset", 1); + } + + PRINT_SPACE + _OUT << "\"dstSubresource\": " << std::endl; + { + print_VkImageSubresourceLayers(obj->dstSubresource, "dstSubresource", 1); + } + + PRINT_SPACE + _OUT << "\"dstOffset\": " << std::endl; + { + print_VkOffset3D(obj->dstOffset, "dstOffset", 1); + } + + PRINT_SPACE + _OUT << "\"extent\": " << std::endl; + { + print_VkExtent3D(obj->extent, "extent", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkResolveImageInfo2KHR(VkResolveImageInfo2KHR obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "srcImage" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkImageLayout(obj.srcImageLayout, "srcImageLayout", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "dstImage" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkImageLayout(obj.dstImageLayout, "dstImageLayout", 1); + + print_uint32_t(obj.regionCount, "regionCount", 1); + + PRINT_SPACE + _OUT << "\"pRegions\": " << std::endl; + if (obj.pRegions) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.regionCount; i++) { + if (i+1 == obj.regionCount) + print_VkImageResolve2KHR(obj.pRegions[i], "pRegions", 0); + else + print_VkImageResolve2KHR(obj.pRegions[i], "pRegions", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkResolveImageInfo2KHR(const VkResolveImageInfo2KHR * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "srcImage" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkImageLayout(obj->srcImageLayout, "srcImageLayout", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE _OUT << "\"" << "dstImage" << "\"" << " : " << "\"" << "\"," << std::endl; + + print_VkImageLayout(obj->dstImageLayout, "dstImageLayout", 1); + + print_uint32_t(obj->regionCount, "regionCount", 1); + + PRINT_SPACE + _OUT << "\"pRegions\": " << std::endl; + if (obj->pRegions) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->regionCount; i++) { + if (i+1 == obj->regionCount) + print_VkImageResolve2KHR(obj->pRegions[i], "pRegions", 0); + else + print_VkImageResolve2KHR(obj->pRegions[i], "pRegions", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.textureCompressionASTC_HDR, "textureCompressionASTC_HDR", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->textureCompressionASTC_HDR, "textureCompressionASTC_HDR", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageViewASTCDecodeModeEXT(VkImageViewASTCDecodeModeEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkFormat(obj.decodeMode, "decodeMode", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageViewASTCDecodeModeEXT(const VkImageViewASTCDecodeModeEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkFormat(obj->decodeMode, "decodeMode", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceASTCDecodeFeaturesEXT(VkPhysicalDeviceASTCDecodeFeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.decodeModeSharedExponent, "decodeModeSharedExponent", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceASTCDecodeFeaturesEXT(const VkPhysicalDeviceASTCDecodeFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->decodeModeSharedExponent, "decodeModeSharedExponent", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static std::map VkSurfaceCounterFlagBitsEXT_map = { + std::make_pair(1ULL << 0, "VK_SURFACE_COUNTER_VBLANK_BIT_EXT"), +}; +static void print_VkSurfaceCounterFlagBitsEXT(VkSurfaceCounterFlagBitsEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSurfaceCounterFlagBitsEXT_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSurfaceCounterFlagBitsEXT_map[obj] << "\"" << std::endl; +} +static void print_VkSurfaceCounterFlagBitsEXT(const VkSurfaceCounterFlagBitsEXT * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkSurfaceCounterFlagBitsEXT_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkSurfaceCounterFlagBitsEXT_map[*obj] << "\"" << std::endl; +} + +static void print_VkSurfaceCounterFlagsEXT(VkSurfaceCounterFlagsEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + const int max_bits = 64; // We don't expect the number to be larger. + std::bitset b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkSurfaceCounterFlagBitsEXT_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkSurfaceCounterFlagBitsEXT_map[1ULL<sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->minImageCount, "minImageCount", 1); + + print_uint32_t(obj->maxImageCount, "maxImageCount", 1); + + PRINT_SPACE + _OUT << "\"currentExtent\": " << std::endl; + { + print_VkExtent2D(obj->currentExtent, "currentExtent", 1); + } + + PRINT_SPACE + _OUT << "\"minImageExtent\": " << std::endl; + { + print_VkExtent2D(obj->minImageExtent, "minImageExtent", 1); + } + + PRINT_SPACE + _OUT << "\"maxImageExtent\": " << std::endl; + { + print_VkExtent2D(obj->maxImageExtent, "maxImageExtent", 1); + } + + print_uint32_t(obj->maxImageArrayLayers, "maxImageArrayLayers", 1); + + print_VkSurfaceTransformFlagsKHR(obj->supportedTransforms, "supportedTransforms", 1); + + print_VkSurfaceTransformFlagBitsKHR(obj->currentTransform, "currentTransform", 1); + + print_VkCompositeAlphaFlagsKHR(obj->supportedCompositeAlpha, "supportedCompositeAlpha", 1); + + print_VkImageUsageFlags(obj->supportedUsageFlags, "supportedUsageFlags", 1); + + print_VkSurfaceCounterFlagsEXT(obj->supportedSurfaceCounters, "supportedSurfaceCounters", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static std::map VkDisplayPowerStateEXT_map = { + std::make_pair(0, "VK_DISPLAY_POWER_STATE_OFF_EXT"), + std::make_pair(1, "VK_DISPLAY_POWER_STATE_SUSPEND_EXT"), + std::make_pair(2, "VK_DISPLAY_POWER_STATE_ON_EXT"), +}; +static void print_VkDisplayPowerStateEXT(VkDisplayPowerStateEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDisplayPowerStateEXT_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDisplayPowerStateEXT_map[obj] << "\"" << std::endl; +} +static void print_VkDisplayPowerStateEXT(const VkDisplayPowerStateEXT * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDisplayPowerStateEXT_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDisplayPowerStateEXT_map[*obj] << "\"" << std::endl; +} + +static std::map VkDeviceEventTypeEXT_map = { + std::make_pair(0, "VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT"), +}; +static void print_VkDeviceEventTypeEXT(VkDeviceEventTypeEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDeviceEventTypeEXT_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDeviceEventTypeEXT_map[obj] << "\"" << std::endl; +} +static void print_VkDeviceEventTypeEXT(const VkDeviceEventTypeEXT * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDeviceEventTypeEXT_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDeviceEventTypeEXT_map[*obj] << "\"" << std::endl; +} + +static std::map VkDisplayEventTypeEXT_map = { + std::make_pair(0, "VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT"), +}; +static void print_VkDisplayEventTypeEXT(VkDisplayEventTypeEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDisplayEventTypeEXT_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDisplayEventTypeEXT_map[obj] << "\"" << std::endl; +} +static void print_VkDisplayEventTypeEXT(const VkDisplayEventTypeEXT * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDisplayEventTypeEXT_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDisplayEventTypeEXT_map[*obj] << "\"" << std::endl; +} + +static void print_VkDisplayPowerInfoEXT(VkDisplayPowerInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDisplayPowerStateEXT(obj.powerState, "powerState", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDisplayPowerInfoEXT(const VkDisplayPowerInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDisplayPowerStateEXT(obj->powerState, "powerState", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDeviceEventInfoEXT(VkDeviceEventInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceEventTypeEXT(obj.deviceEvent, "deviceEvent", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDeviceEventInfoEXT(const VkDeviceEventInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceEventTypeEXT(obj->deviceEvent, "deviceEvent", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDisplayEventInfoEXT(VkDisplayEventInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDisplayEventTypeEXT(obj.displayEvent, "displayEvent", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDisplayEventInfoEXT(const VkDisplayEventInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDisplayEventTypeEXT(obj->displayEvent, "displayEvent", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSwapchainCounterCreateInfoEXT(VkSwapchainCounterCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSurfaceCounterFlagsEXT(obj.surfaceCounters, "surfaceCounters", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSurfaceCounterFlagsEXT(obj->surfaceCounters, "surfaceCounters", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static std::map VkDiscardRectangleModeEXT_map = { + std::make_pair(0, "VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT"), + std::make_pair(1, "VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT"), +}; +static void print_VkDiscardRectangleModeEXT(VkDiscardRectangleModeEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDiscardRectangleModeEXT_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDiscardRectangleModeEXT_map[obj] << "\"" << std::endl; +} +static void print_VkDiscardRectangleModeEXT(const VkDiscardRectangleModeEXT * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDiscardRectangleModeEXT_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDiscardRectangleModeEXT_map[*obj] << "\"" << std::endl; +} + +static void print_VkPipelineDiscardRectangleStateCreateFlagsEXT(VkPipelineDiscardRectangleStateCreateFlagsEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl; + else + _OUT << "\"" << str << "\"" << " : " << obj << std::endl; +} +static void print_VkPipelineDiscardRectangleStateCreateFlagsEXT(const VkPipelineDiscardRectangleStateCreateFlagsEXT * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl; + else + _OUT << "\"" << str << "\"" << " : " << obj << std::endl; +} + +static void print_VkPhysicalDeviceDiscardRectanglePropertiesEXT(VkPhysicalDeviceDiscardRectanglePropertiesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.maxDiscardRectangles, "maxDiscardRectangles", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const VkPhysicalDeviceDiscardRectanglePropertiesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->maxDiscardRectangles, "maxDiscardRectangles", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineDiscardRectangleStateCreateInfoEXT(VkPipelineDiscardRectangleStateCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineDiscardRectangleStateCreateFlagsEXT(obj.flags, "flags", 1); + + print_VkDiscardRectangleModeEXT(obj.discardRectangleMode, "discardRectangleMode", 1); + + print_uint32_t(obj.discardRectangleCount, "discardRectangleCount", 1); + + PRINT_SPACE + _OUT << "\"pDiscardRectangles\": " << std::endl; + if (obj.pDiscardRectangles) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.discardRectangleCount; i++) { + if (i+1 == obj.discardRectangleCount) + print_VkRect2D(obj.pDiscardRectangles[i], "pDiscardRectangles", 0); + else + print_VkRect2D(obj.pDiscardRectangles[i], "pDiscardRectangles", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineDiscardRectangleStateCreateInfoEXT(const VkPipelineDiscardRectangleStateCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineDiscardRectangleStateCreateFlagsEXT(obj->flags, "flags", 1); + + print_VkDiscardRectangleModeEXT(obj->discardRectangleMode, "discardRectangleMode", 1); + + print_uint32_t(obj->discardRectangleCount, "discardRectangleCount", 1); + + PRINT_SPACE + _OUT << "\"pDiscardRectangles\": " << std::endl; + if (obj->pDiscardRectangles) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->discardRectangleCount; i++) { + if (i+1 == obj->discardRectangleCount) + print_VkRect2D(obj->pDiscardRectangles[i], "pDiscardRectangles", 0); + else + print_VkRect2D(obj->pDiscardRectangles[i], "pDiscardRectangles", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static std::map VkConservativeRasterizationModeEXT_map = { + std::make_pair(0, "VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT"), + std::make_pair(1, "VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT"), + std::make_pair(2, "VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT"), +}; +static void print_VkConservativeRasterizationModeEXT(VkConservativeRasterizationModeEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkConservativeRasterizationModeEXT_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkConservativeRasterizationModeEXT_map[obj] << "\"" << std::endl; +} +static void print_VkConservativeRasterizationModeEXT(const VkConservativeRasterizationModeEXT * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkConservativeRasterizationModeEXT_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkConservativeRasterizationModeEXT_map[*obj] << "\"" << std::endl; +} + +static void print_VkPipelineRasterizationConservativeStateCreateFlagsEXT(VkPipelineRasterizationConservativeStateCreateFlagsEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl; + else + _OUT << "\"" << str << "\"" << " : " << obj << std::endl; +} +static void print_VkPipelineRasterizationConservativeStateCreateFlagsEXT(const VkPipelineRasterizationConservativeStateCreateFlagsEXT * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl; + else + _OUT << "\"" << str << "\"" << " : " << obj << std::endl; +} + +static void print_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(VkPhysicalDeviceConservativeRasterizationPropertiesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_float(obj.primitiveOverestimationSize, "primitiveOverestimationSize", 1); + + print_float(obj.maxExtraPrimitiveOverestimationSize, "maxExtraPrimitiveOverestimationSize", 1); + + print_float(obj.extraPrimitiveOverestimationSizeGranularity, "extraPrimitiveOverestimationSizeGranularity", 1); + + print_VkBool32(obj.primitiveUnderestimation, "primitiveUnderestimation", 1); + + print_VkBool32(obj.conservativePointAndLineRasterization, "conservativePointAndLineRasterization", 1); + + print_VkBool32(obj.degenerateTrianglesRasterized, "degenerateTrianglesRasterized", 1); + + print_VkBool32(obj.degenerateLinesRasterized, "degenerateLinesRasterized", 1); + + print_VkBool32(obj.fullyCoveredFragmentShaderInputVariable, "fullyCoveredFragmentShaderInputVariable", 1); + + print_VkBool32(obj.conservativeRasterizationPostDepthCoverage, "conservativeRasterizationPostDepthCoverage", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_float(obj->primitiveOverestimationSize, "primitiveOverestimationSize", 1); + + print_float(obj->maxExtraPrimitiveOverestimationSize, "maxExtraPrimitiveOverestimationSize", 1); + + print_float(obj->extraPrimitiveOverestimationSizeGranularity, "extraPrimitiveOverestimationSizeGranularity", 1); + + print_VkBool32(obj->primitiveUnderestimation, "primitiveUnderestimation", 1); + + print_VkBool32(obj->conservativePointAndLineRasterization, "conservativePointAndLineRasterization", 1); + + print_VkBool32(obj->degenerateTrianglesRasterized, "degenerateTrianglesRasterized", 1); + + print_VkBool32(obj->degenerateLinesRasterized, "degenerateLinesRasterized", 1); + + print_VkBool32(obj->fullyCoveredFragmentShaderInputVariable, "fullyCoveredFragmentShaderInputVariable", 1); + + print_VkBool32(obj->conservativeRasterizationPostDepthCoverage, "conservativeRasterizationPostDepthCoverage", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineRasterizationConservativeStateCreateInfoEXT(VkPipelineRasterizationConservativeStateCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineRasterizationConservativeStateCreateFlagsEXT(obj.flags, "flags", 1); + + print_VkConservativeRasterizationModeEXT(obj.conservativeRasterizationMode, "conservativeRasterizationMode", 1); + + print_float(obj.extraPrimitiveOverestimationSize, "extraPrimitiveOverestimationSize", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineRasterizationConservativeStateCreateInfoEXT(const VkPipelineRasterizationConservativeStateCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineRasterizationConservativeStateCreateFlagsEXT(obj->flags, "flags", 1); + + print_VkConservativeRasterizationModeEXT(obj->conservativeRasterizationMode, "conservativeRasterizationMode", 1); + + print_float(obj->extraPrimitiveOverestimationSize, "extraPrimitiveOverestimationSize", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(VkPipelineRasterizationDepthClipStateCreateFlagsEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl; + else + _OUT << "\"" << str << "\"" << " : " << obj << std::endl; +} +static void print_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(const VkPipelineRasterizationDepthClipStateCreateFlagsEXT * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl; + else + _OUT << "\"" << str << "\"" << " : " << obj << std::endl; +} + +static void print_VkPhysicalDeviceDepthClipEnableFeaturesEXT(VkPhysicalDeviceDepthClipEnableFeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.depthClipEnable, "depthClipEnable", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const VkPhysicalDeviceDepthClipEnableFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->depthClipEnable, "depthClipEnable", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineRasterizationDepthClipStateCreateInfoEXT(VkPipelineRasterizationDepthClipStateCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(obj.flags, "flags", 1); + + print_VkBool32(obj.depthClipEnable, "depthClipEnable", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const VkPipelineRasterizationDepthClipStateCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(obj->flags, "flags", 1); + + print_VkBool32(obj->depthClipEnable, "depthClipEnable", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkXYColorEXT(VkXYColorEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_float(obj.x, "x", 1); + + print_float(obj.y, "y", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkXYColorEXT(const VkXYColorEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_float(obj->x, "x", 1); + + print_float(obj->y, "y", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkHdrMetadataEXT(VkHdrMetadataEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"displayPrimaryRed\": " << std::endl; + { + print_VkXYColorEXT(obj.displayPrimaryRed, "displayPrimaryRed", 1); + } + + PRINT_SPACE + _OUT << "\"displayPrimaryGreen\": " << std::endl; + { + print_VkXYColorEXT(obj.displayPrimaryGreen, "displayPrimaryGreen", 1); + } + + PRINT_SPACE + _OUT << "\"displayPrimaryBlue\": " << std::endl; + { + print_VkXYColorEXT(obj.displayPrimaryBlue, "displayPrimaryBlue", 1); + } + + PRINT_SPACE + _OUT << "\"whitePoint\": " << std::endl; + { + print_VkXYColorEXT(obj.whitePoint, "whitePoint", 1); + } + + print_float(obj.maxLuminance, "maxLuminance", 1); + + print_float(obj.minLuminance, "minLuminance", 1); + + print_float(obj.maxContentLightLevel, "maxContentLightLevel", 1); + + print_float(obj.maxFrameAverageLightLevel, "maxFrameAverageLightLevel", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkHdrMetadataEXT(const VkHdrMetadataEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"displayPrimaryRed\": " << std::endl; + { + print_VkXYColorEXT(obj->displayPrimaryRed, "displayPrimaryRed", 1); + } + + PRINT_SPACE + _OUT << "\"displayPrimaryGreen\": " << std::endl; + { + print_VkXYColorEXT(obj->displayPrimaryGreen, "displayPrimaryGreen", 1); + } + + PRINT_SPACE + _OUT << "\"displayPrimaryBlue\": " << std::endl; + { + print_VkXYColorEXT(obj->displayPrimaryBlue, "displayPrimaryBlue", 1); + } + + PRINT_SPACE + _OUT << "\"whitePoint\": " << std::endl; + { + print_VkXYColorEXT(obj->whitePoint, "whitePoint", 1); + } + + print_float(obj->maxLuminance, "maxLuminance", 1); + + print_float(obj->minLuminance, "minLuminance", 1); + + print_float(obj->maxContentLightLevel, "maxContentLightLevel", 1); + + print_float(obj->maxFrameAverageLightLevel, "maxFrameAverageLightLevel", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDebugUtilsMessengerEXT(VkDebugUtilsMessengerEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} +static void print_VkDebugUtilsMessengerEXT(const VkDebugUtilsMessengerEXT * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << "," << std::endl; + else + _OUT << "\"" << str << "\"" << std::endl; +} + +static std::map VkDebugUtilsMessageSeverityFlagBitsEXT_map = { + std::make_pair(1ULL << 0, "VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT"), + std::make_pair(1ULL << 4, "VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT"), + std::make_pair(1ULL << 8, "VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT"), + std::make_pair(1ULL << 12, "VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT"), +}; +static void print_VkDebugUtilsMessageSeverityFlagBitsEXT(VkDebugUtilsMessageSeverityFlagBitsEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDebugUtilsMessageSeverityFlagBitsEXT_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDebugUtilsMessageSeverityFlagBitsEXT_map[obj] << "\"" << std::endl; +} +static void print_VkDebugUtilsMessageSeverityFlagBitsEXT(const VkDebugUtilsMessageSeverityFlagBitsEXT * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDebugUtilsMessageSeverityFlagBitsEXT_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDebugUtilsMessageSeverityFlagBitsEXT_map[*obj] << "\"" << std::endl; +} + +static std::map VkDebugUtilsMessageTypeFlagBitsEXT_map = { + std::make_pair(1ULL << 0, "VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT"), + std::make_pair(1ULL << 1, "VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT"), + std::make_pair(1ULL << 2, "VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT"), +}; +static void print_VkDebugUtilsMessageTypeFlagBitsEXT(VkDebugUtilsMessageTypeFlagBitsEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDebugUtilsMessageTypeFlagBitsEXT_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDebugUtilsMessageTypeFlagBitsEXT_map[obj] << "\"" << std::endl; +} +static void print_VkDebugUtilsMessageTypeFlagBitsEXT(const VkDebugUtilsMessageTypeFlagBitsEXT * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkDebugUtilsMessageTypeFlagBitsEXT_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkDebugUtilsMessageTypeFlagBitsEXT_map[*obj] << "\"" << std::endl; +} + +static void print_VkDebugUtilsMessengerCallbackDataFlagsEXT(VkDebugUtilsMessengerCallbackDataFlagsEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl; + else + _OUT << "\"" << str << "\"" << " : " << obj << std::endl; +} +static void print_VkDebugUtilsMessengerCallbackDataFlagsEXT(const VkDebugUtilsMessengerCallbackDataFlagsEXT * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl; + else + _OUT << "\"" << str << "\"" << " : " << obj << std::endl; +} + +static void print_VkDebugUtilsMessageTypeFlagsEXT(VkDebugUtilsMessageTypeFlagsEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + const int max_bits = 64; // We don't expect the number to be larger. + std::bitset b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkDebugUtilsMessageTypeFlagBitsEXT_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkDebugUtilsMessageTypeFlagBitsEXT_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkDebugUtilsMessageSeverityFlagBitsEXT_map[1ULL< b(obj); + _OUT << "\""; + if (obj == 0) _OUT << "0"; + for (unsigned int i = 0, bitCount = 0; i < b.size(); i++) { + if (b[i] == 1) { + bitCount++; + if (bitCount < b.count()) + _OUT << VkDebugUtilsMessageSeverityFlagBitsEXT_map[1ULL<sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_char(obj->pLabelName, "pLabelName", 1); + + PRINT_SPACE + _OUT << "\"color\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 4; i++) { + bool isCommaNeeded = (i+1) != 4; + print_float(obj->color[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDebugUtilsObjectNameInfoEXT(VkDebugUtilsObjectNameInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkObjectType(obj.objectType, "objectType", 1); + + print_uint64_t(obj.objectHandle, "objectHandle", 1); + + print_char(obj.pObjectName, "pObjectName", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDebugUtilsObjectNameInfoEXT(const VkDebugUtilsObjectNameInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkObjectType(obj->objectType, "objectType", 1); + + print_uint64_t(obj->objectHandle, "objectHandle", 1); + + print_char(obj->pObjectName, "pObjectName", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDebugUtilsMessengerCallbackDataEXT(VkDebugUtilsMessengerCallbackDataEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDebugUtilsMessengerCallbackDataFlagsEXT(obj.flags, "flags", 1); + + print_char(obj.pMessageIdName, "pMessageIdName", 1); + + print_int32_t(obj.messageIdNumber, "messageIdNumber", 1); + + print_char(obj.pMessage, "pMessage", 1); + + print_uint32_t(obj.queueLabelCount, "queueLabelCount", 1); + + PRINT_SPACE + _OUT << "\"pQueueLabels\": " << std::endl; + if (obj.pQueueLabels) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.queueLabelCount; i++) { + if (i+1 == obj.queueLabelCount) + print_VkDebugUtilsLabelEXT(obj.pQueueLabels[i], "pQueueLabels", 0); + else + print_VkDebugUtilsLabelEXT(obj.pQueueLabels[i], "pQueueLabels", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.cmdBufLabelCount, "cmdBufLabelCount", 1); + + PRINT_SPACE + _OUT << "\"pCmdBufLabels\": " << std::endl; + if (obj.pCmdBufLabels) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.cmdBufLabelCount; i++) { + if (i+1 == obj.cmdBufLabelCount) + print_VkDebugUtilsLabelEXT(obj.pCmdBufLabels[i], "pCmdBufLabels", 0); + else + print_VkDebugUtilsLabelEXT(obj.pCmdBufLabels[i], "pCmdBufLabels", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.objectCount, "objectCount", 1); + + PRINT_SPACE + _OUT << "\"pObjects\": " << std::endl; + if (obj.pObjects) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.objectCount; i++) { + if (i+1 == obj.objectCount) + print_VkDebugUtilsObjectNameInfoEXT(obj.pObjects[i], "pObjects", 0); + else + print_VkDebugUtilsObjectNameInfoEXT(obj.pObjects[i], "pObjects", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDebugUtilsMessengerCallbackDataEXT(const VkDebugUtilsMessengerCallbackDataEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDebugUtilsMessengerCallbackDataFlagsEXT(obj->flags, "flags", 1); + + print_char(obj->pMessageIdName, "pMessageIdName", 1); + + print_int32_t(obj->messageIdNumber, "messageIdNumber", 1); + + print_char(obj->pMessage, "pMessage", 1); + + print_uint32_t(obj->queueLabelCount, "queueLabelCount", 1); + + PRINT_SPACE + _OUT << "\"pQueueLabels\": " << std::endl; + if (obj->pQueueLabels) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->queueLabelCount; i++) { + if (i+1 == obj->queueLabelCount) + print_VkDebugUtilsLabelEXT(obj->pQueueLabels[i], "pQueueLabels", 0); + else + print_VkDebugUtilsLabelEXT(obj->pQueueLabels[i], "pQueueLabels", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->cmdBufLabelCount, "cmdBufLabelCount", 1); + + PRINT_SPACE + _OUT << "\"pCmdBufLabels\": " << std::endl; + if (obj->pCmdBufLabels) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->cmdBufLabelCount; i++) { + if (i+1 == obj->cmdBufLabelCount) + print_VkDebugUtilsLabelEXT(obj->pCmdBufLabels[i], "pCmdBufLabels", 0); + else + print_VkDebugUtilsLabelEXT(obj->pCmdBufLabels[i], "pCmdBufLabels", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->objectCount, "objectCount", 1); + + PRINT_SPACE + _OUT << "\"pObjects\": " << std::endl; + if (obj->pObjects) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->objectCount; i++) { + if (i+1 == obj->objectCount) + print_VkDebugUtilsObjectNameInfoEXT(obj->pObjects[i], "pObjects", 0); + else + print_VkDebugUtilsObjectNameInfoEXT(obj->pObjects[i], "pObjects", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDebugUtilsMessengerCreateInfoEXT(VkDebugUtilsMessengerCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDebugUtilsMessengerCreateFlagsEXT(obj.flags, "flags", 1); + + print_VkDebugUtilsMessageSeverityFlagsEXT(obj.messageSeverity, "messageSeverity", 1); + + print_VkDebugUtilsMessageTypeFlagsEXT(obj.messageType, "messageType", 1); + + /** Note: Ignoring function pointer (PFN_vkDebugUtilsMessengerCallbackEXT). **/ + + /** Note: Ignoring void* data. **/ + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDebugUtilsMessengerCreateInfoEXT(const VkDebugUtilsMessengerCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDebugUtilsMessengerCreateFlagsEXT(obj->flags, "flags", 1); + + print_VkDebugUtilsMessageSeverityFlagsEXT(obj->messageSeverity, "messageSeverity", 1); + + print_VkDebugUtilsMessageTypeFlagsEXT(obj->messageType, "messageType", 1); + + /** Note: Ignoring function pointer (PFN_vkDebugUtilsMessengerCallbackEXT). **/ + + /** Note: Ignoring void* data. **/ + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDebugUtilsObjectTagInfoEXT(VkDebugUtilsObjectTagInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkObjectType(obj.objectType, "objectType", 1); + + print_uint64_t(obj.objectHandle, "objectHandle", 1); + + print_uint64_t(obj.tagName, "tagName", 1); + + print_size_t(obj.tagSize, "tagSize", 1); + + /** Note: Ignoring void* data. **/ + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDebugUtilsObjectTagInfoEXT(const VkDebugUtilsObjectTagInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkObjectType(obj->objectType, "objectType", 1); + + print_uint64_t(obj->objectHandle, "objectHandle", 1); + + print_uint64_t(obj->tagName, "tagName", 1); + + print_size_t(obj->tagSize, "tagSize", 1); + + /** Note: Ignoring void* data. **/ + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSampleLocationEXT(VkSampleLocationEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_float(obj.x, "x", 1); + + print_float(obj.y, "y", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSampleLocationEXT(const VkSampleLocationEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_float(obj->x, "x", 1); + + print_float(obj->y, "y", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSampleLocationsInfoEXT(VkSampleLocationsInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSampleCountFlagBits(obj.sampleLocationsPerPixel, "sampleLocationsPerPixel", 1); + + PRINT_SPACE + _OUT << "\"sampleLocationGridSize\": " << std::endl; + { + print_VkExtent2D(obj.sampleLocationGridSize, "sampleLocationGridSize", 1); + } + + print_uint32_t(obj.sampleLocationsCount, "sampleLocationsCount", 1); + + PRINT_SPACE + _OUT << "\"pSampleLocations\": " << std::endl; + if (obj.pSampleLocations) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.sampleLocationsCount; i++) { + if (i+1 == obj.sampleLocationsCount) + print_VkSampleLocationEXT(obj.pSampleLocations[i], "pSampleLocations", 0); + else + print_VkSampleLocationEXT(obj.pSampleLocations[i], "pSampleLocations", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSampleLocationsInfoEXT(const VkSampleLocationsInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSampleCountFlagBits(obj->sampleLocationsPerPixel, "sampleLocationsPerPixel", 1); + + PRINT_SPACE + _OUT << "\"sampleLocationGridSize\": " << std::endl; + { + print_VkExtent2D(obj->sampleLocationGridSize, "sampleLocationGridSize", 1); + } + + print_uint32_t(obj->sampleLocationsCount, "sampleLocationsCount", 1); + + PRINT_SPACE + _OUT << "\"pSampleLocations\": " << std::endl; + if (obj->pSampleLocations) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->sampleLocationsCount; i++) { + if (i+1 == obj->sampleLocationsCount) + print_VkSampleLocationEXT(obj->pSampleLocations[i], "pSampleLocations", 0); + else + print_VkSampleLocationEXT(obj->pSampleLocations[i], "pSampleLocations", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkAttachmentSampleLocationsEXT(VkAttachmentSampleLocationsEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj.attachmentIndex, "attachmentIndex", 1); + + PRINT_SPACE + _OUT << "\"sampleLocationsInfo\": " << std::endl; + { + print_VkSampleLocationsInfoEXT(obj.sampleLocationsInfo, "sampleLocationsInfo", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkAttachmentSampleLocationsEXT(const VkAttachmentSampleLocationsEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj->attachmentIndex, "attachmentIndex", 1); + + PRINT_SPACE + _OUT << "\"sampleLocationsInfo\": " << std::endl; + { + print_VkSampleLocationsInfoEXT(obj->sampleLocationsInfo, "sampleLocationsInfo", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSubpassSampleLocationsEXT(VkSubpassSampleLocationsEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj.subpassIndex, "subpassIndex", 1); + + PRINT_SPACE + _OUT << "\"sampleLocationsInfo\": " << std::endl; + { + print_VkSampleLocationsInfoEXT(obj.sampleLocationsInfo, "sampleLocationsInfo", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSubpassSampleLocationsEXT(const VkSubpassSampleLocationsEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj->subpassIndex, "subpassIndex", 1); + + PRINT_SPACE + _OUT << "\"sampleLocationsInfo\": " << std::endl; + { + print_VkSampleLocationsInfoEXT(obj->sampleLocationsInfo, "sampleLocationsInfo", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkRenderPassSampleLocationsBeginInfoEXT(VkRenderPassSampleLocationsBeginInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.attachmentInitialSampleLocationsCount, "attachmentInitialSampleLocationsCount", 1); + + PRINT_SPACE + _OUT << "\"pAttachmentInitialSampleLocations\": " << std::endl; + if (obj.pAttachmentInitialSampleLocations) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.attachmentInitialSampleLocationsCount; i++) { + if (i+1 == obj.attachmentInitialSampleLocationsCount) + print_VkAttachmentSampleLocationsEXT(obj.pAttachmentInitialSampleLocations[i], "pAttachmentInitialSampleLocations", 0); + else + print_VkAttachmentSampleLocationsEXT(obj.pAttachmentInitialSampleLocations[i], "pAttachmentInitialSampleLocations", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.postSubpassSampleLocationsCount, "postSubpassSampleLocationsCount", 1); + + PRINT_SPACE + _OUT << "\"pPostSubpassSampleLocations\": " << std::endl; + if (obj.pPostSubpassSampleLocations) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.postSubpassSampleLocationsCount; i++) { + if (i+1 == obj.postSubpassSampleLocationsCount) + print_VkSubpassSampleLocationsEXT(obj.pPostSubpassSampleLocations[i], "pPostSubpassSampleLocations", 0); + else + print_VkSubpassSampleLocationsEXT(obj.pPostSubpassSampleLocations[i], "pPostSubpassSampleLocations", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkRenderPassSampleLocationsBeginInfoEXT(const VkRenderPassSampleLocationsBeginInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->attachmentInitialSampleLocationsCount, "attachmentInitialSampleLocationsCount", 1); + + PRINT_SPACE + _OUT << "\"pAttachmentInitialSampleLocations\": " << std::endl; + if (obj->pAttachmentInitialSampleLocations) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->attachmentInitialSampleLocationsCount; i++) { + if (i+1 == obj->attachmentInitialSampleLocationsCount) + print_VkAttachmentSampleLocationsEXT(obj->pAttachmentInitialSampleLocations[i], "pAttachmentInitialSampleLocations", 0); + else + print_VkAttachmentSampleLocationsEXT(obj->pAttachmentInitialSampleLocations[i], "pAttachmentInitialSampleLocations", 1); + } + PRINT_SPACE + _OUT << "]," << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->postSubpassSampleLocationsCount, "postSubpassSampleLocationsCount", 1); + + PRINT_SPACE + _OUT << "\"pPostSubpassSampleLocations\": " << std::endl; + if (obj->pPostSubpassSampleLocations) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->postSubpassSampleLocationsCount; i++) { + if (i+1 == obj->postSubpassSampleLocationsCount) + print_VkSubpassSampleLocationsEXT(obj->pPostSubpassSampleLocations[i], "pPostSubpassSampleLocations", 0); + else + print_VkSubpassSampleLocationsEXT(obj->pPostSubpassSampleLocations[i], "pPostSubpassSampleLocations", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineSampleLocationsStateCreateInfoEXT(VkPipelineSampleLocationsStateCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.sampleLocationsEnable, "sampleLocationsEnable", 1); + + PRINT_SPACE + _OUT << "\"sampleLocationsInfo\": " << std::endl; + { + print_VkSampleLocationsInfoEXT(obj.sampleLocationsInfo, "sampleLocationsInfo", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineSampleLocationsStateCreateInfoEXT(const VkPipelineSampleLocationsStateCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->sampleLocationsEnable, "sampleLocationsEnable", 1); + + PRINT_SPACE + _OUT << "\"sampleLocationsInfo\": " << std::endl; + { + print_VkSampleLocationsInfoEXT(obj->sampleLocationsInfo, "sampleLocationsInfo", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceSampleLocationsPropertiesEXT(VkPhysicalDeviceSampleLocationsPropertiesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSampleCountFlags(obj.sampleLocationSampleCounts, "sampleLocationSampleCounts", 1); + + PRINT_SPACE + _OUT << "\"maxSampleLocationGridSize\": " << std::endl; + { + print_VkExtent2D(obj.maxSampleLocationGridSize, "maxSampleLocationGridSize", 1); + } + + PRINT_SPACE + _OUT << "\"sampleLocationCoordinateRange\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 2; i++) { + bool isCommaNeeded = (i+1) != 2; + print_float(obj.sampleLocationCoordinateRange[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_uint32_t(obj.sampleLocationSubPixelBits, "sampleLocationSubPixelBits", 1); + + print_VkBool32(obj.variableSampleLocations, "variableSampleLocations", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceSampleLocationsPropertiesEXT(const VkPhysicalDeviceSampleLocationsPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkSampleCountFlags(obj->sampleLocationSampleCounts, "sampleLocationSampleCounts", 1); + + PRINT_SPACE + _OUT << "\"maxSampleLocationGridSize\": " << std::endl; + { + print_VkExtent2D(obj->maxSampleLocationGridSize, "maxSampleLocationGridSize", 1); + } + + PRINT_SPACE + _OUT << "\"sampleLocationCoordinateRange\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < 2; i++) { + bool isCommaNeeded = (i+1) != 2; + print_float(obj->sampleLocationCoordinateRange[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + print_uint32_t(obj->sampleLocationSubPixelBits, "sampleLocationSubPixelBits", 1); + + print_VkBool32(obj->variableSampleLocations, "variableSampleLocations", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkMultisamplePropertiesEXT(VkMultisamplePropertiesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"maxSampleLocationGridSize\": " << std::endl; + { + print_VkExtent2D(obj.maxSampleLocationGridSize, "maxSampleLocationGridSize", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkMultisamplePropertiesEXT(const VkMultisamplePropertiesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"maxSampleLocationGridSize\": " << std::endl; + { + print_VkExtent2D(obj->maxSampleLocationGridSize, "maxSampleLocationGridSize", 0); + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static std::map VkBlendOverlapEXT_map = { + std::make_pair(0, "VK_BLEND_OVERLAP_UNCORRELATED_EXT"), + std::make_pair(1, "VK_BLEND_OVERLAP_DISJOINT_EXT"), + std::make_pair(2, "VK_BLEND_OVERLAP_CONJOINT_EXT"), +}; +static void print_VkBlendOverlapEXT(VkBlendOverlapEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkBlendOverlapEXT_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkBlendOverlapEXT_map[obj] << "\"" << std::endl; +} +static void print_VkBlendOverlapEXT(const VkBlendOverlapEXT * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkBlendOverlapEXT_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkBlendOverlapEXT_map[*obj] << "\"" << std::endl; +} + +static void print_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.advancedBlendCoherentOperations, "advancedBlendCoherentOperations", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->advancedBlendCoherentOperations, "advancedBlendCoherentOperations", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.advancedBlendMaxColorAttachments, "advancedBlendMaxColorAttachments", 1); + + print_VkBool32(obj.advancedBlendIndependentBlend, "advancedBlendIndependentBlend", 1); + + print_VkBool32(obj.advancedBlendNonPremultipliedSrcColor, "advancedBlendNonPremultipliedSrcColor", 1); + + print_VkBool32(obj.advancedBlendNonPremultipliedDstColor, "advancedBlendNonPremultipliedDstColor", 1); + + print_VkBool32(obj.advancedBlendCorrelatedOverlap, "advancedBlendCorrelatedOverlap", 1); + + print_VkBool32(obj.advancedBlendAllOperations, "advancedBlendAllOperations", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->advancedBlendMaxColorAttachments, "advancedBlendMaxColorAttachments", 1); + + print_VkBool32(obj->advancedBlendIndependentBlend, "advancedBlendIndependentBlend", 1); + + print_VkBool32(obj->advancedBlendNonPremultipliedSrcColor, "advancedBlendNonPremultipliedSrcColor", 1); + + print_VkBool32(obj->advancedBlendNonPremultipliedDstColor, "advancedBlendNonPremultipliedDstColor", 1); + + print_VkBool32(obj->advancedBlendCorrelatedOverlap, "advancedBlendCorrelatedOverlap", 1); + + print_VkBool32(obj->advancedBlendAllOperations, "advancedBlendAllOperations", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineColorBlendAdvancedStateCreateInfoEXT(VkPipelineColorBlendAdvancedStateCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.srcPremultiplied, "srcPremultiplied", 1); + + print_VkBool32(obj.dstPremultiplied, "dstPremultiplied", 1); + + print_VkBlendOverlapEXT(obj.blendOverlap, "blendOverlap", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const VkPipelineColorBlendAdvancedStateCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->srcPremultiplied, "srcPremultiplied", 1); + + print_VkBool32(obj->dstPremultiplied, "dstPremultiplied", 1); + + print_VkBlendOverlapEXT(obj->blendOverlap, "blendOverlap", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static std::map VkFormatFeatureFlagBits2KHR_map = { + std::make_pair(1ULL << 0, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR"), + std::make_pair(1ULL << 1, "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR"), + std::make_pair(1ULL << 2, "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR"), + std::make_pair(1ULL << 3, "VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR"), + std::make_pair(1ULL << 4, "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR"), + std::make_pair(1ULL << 5, "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR"), + std::make_pair(1ULL << 6, "VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR"), + std::make_pair(1ULL << 7, "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR"), + std::make_pair(1ULL << 8, "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR"), + std::make_pair(1ULL << 9, "VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR"), + std::make_pair(1ULL << 10, "VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR"), + std::make_pair(1ULL << 11, "VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR"), + std::make_pair(1ULL << 12, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR"), + std::make_pair(1ULL << 13, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT"), + std::make_pair(1ULL << 14, "VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR"), + std::make_pair(1ULL << 15, "VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR"), + std::make_pair(1ULL << 16, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR"), + std::make_pair(1ULL << 17, "VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR"), + std::make_pair(1ULL << 18, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR"), + std::make_pair(1ULL << 19, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR"), + std::make_pair(1ULL << 20, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR"), + std::make_pair(1ULL << 21, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR"), + std::make_pair(1ULL << 22, "VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR"), + std::make_pair(1ULL << 23, "VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR"), + std::make_pair(1ULL << 31, "VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR"), + std::make_pair(1ULL << 32, "VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR"), + std::make_pair(1ULL << 33, "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR"), + std::make_pair(1ULL << 25, "VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR"), + std::make_pair(1ULL << 26, "VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR"), + std::make_pair(1ULL << 29, "VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR"), + std::make_pair(1ULL << 24, "VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT"), + std::make_pair(1ULL << 30, "VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"), + std::make_pair(1ULL << 27, "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR"), + std::make_pair(1ULL << 28, "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR"), +}; +static void print_VkFormatFeatureFlagBits2KHR(VkFormatFeatureFlagBits2KHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFormatFeatureFlagBits2KHR_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFormatFeatureFlagBits2KHR_map[obj] << "\"" << std::endl; +} +static void print_VkFormatFeatureFlagBits2KHR(const VkFormatFeatureFlagBits2KHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkFormatFeatureFlagBits2KHR_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkFormatFeatureFlagBits2KHR_map[*obj] << "\"" << std::endl; +} + +static void print_VkFormatFeatureFlags2KHR(VkFormatFeatureFlags2KHR obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl; + else + _OUT << "\"" << str << "\"" << " : " << obj << std::endl; +} +static void print_VkFormatFeatureFlags2KHR(const VkFormatFeatureFlags2KHR * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl; + else + _OUT << "\"" << str << "\"" << " : " << obj << std::endl; +} + +static void print_VkDrmFormatModifierPropertiesEXT(VkDrmFormatModifierPropertiesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint64_t(obj.drmFormatModifier, "drmFormatModifier", 1); + + print_uint32_t(obj.drmFormatModifierPlaneCount, "drmFormatModifierPlaneCount", 1); + + print_VkFormatFeatureFlags(obj.drmFormatModifierTilingFeatures, "drmFormatModifierTilingFeatures", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDrmFormatModifierPropertiesEXT(const VkDrmFormatModifierPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint64_t(obj->drmFormatModifier, "drmFormatModifier", 1); + + print_uint32_t(obj->drmFormatModifierPlaneCount, "drmFormatModifierPlaneCount", 1); + + print_VkFormatFeatureFlags(obj->drmFormatModifierTilingFeatures, "drmFormatModifierTilingFeatures", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDrmFormatModifierPropertiesListEXT(VkDrmFormatModifierPropertiesListEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.drmFormatModifierCount, "drmFormatModifierCount", 1); + + PRINT_SPACE + _OUT << "\"pDrmFormatModifierProperties\": " << std::endl; + if (obj.pDrmFormatModifierProperties) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.drmFormatModifierCount; i++) { + if (i+1 == obj.drmFormatModifierCount) + print_VkDrmFormatModifierPropertiesEXT(obj.pDrmFormatModifierProperties[i], "pDrmFormatModifierProperties", 0); + else + print_VkDrmFormatModifierPropertiesEXT(obj.pDrmFormatModifierProperties[i], "pDrmFormatModifierProperties", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->drmFormatModifierCount, "drmFormatModifierCount", 1); + + PRINT_SPACE + _OUT << "\"pDrmFormatModifierProperties\": " << std::endl; + if (obj->pDrmFormatModifierProperties) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->drmFormatModifierCount; i++) { + if (i+1 == obj->drmFormatModifierCount) + print_VkDrmFormatModifierPropertiesEXT(obj->pDrmFormatModifierProperties[i], "pDrmFormatModifierProperties", 0); + else + print_VkDrmFormatModifierPropertiesEXT(obj->pDrmFormatModifierProperties[i], "pDrmFormatModifierProperties", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(VkPhysicalDeviceImageDrmFormatModifierInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint64_t(obj.drmFormatModifier, "drmFormatModifier", 1); + + print_VkSharingMode(obj.sharingMode, "sharingMode", 1); + + print_uint32_t(obj.queueFamilyIndexCount, "queueFamilyIndexCount", 1); + + PRINT_SPACE + _OUT << "\"pQueueFamilyIndices\":" << std::endl; + PRINT_SPACE + if (obj.pQueueFamilyIndices) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.queueFamilyIndexCount; i++) { + bool isCommaNeeded = (i+1) != obj.queueFamilyIndexCount; + print_uint32_t(obj.pQueueFamilyIndices[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint64_t(obj->drmFormatModifier, "drmFormatModifier", 1); + + print_VkSharingMode(obj->sharingMode, "sharingMode", 1); + + print_uint32_t(obj->queueFamilyIndexCount, "queueFamilyIndexCount", 1); + + PRINT_SPACE + _OUT << "\"pQueueFamilyIndices\":" << std::endl; + PRINT_SPACE + if (obj->pQueueFamilyIndices) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->queueFamilyIndexCount; i++) { + bool isCommaNeeded = (i+1) != obj->queueFamilyIndexCount; + print_uint32_t(obj->pQueueFamilyIndices[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageDrmFormatModifierListCreateInfoEXT(VkImageDrmFormatModifierListCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.drmFormatModifierCount, "drmFormatModifierCount", 1); + + PRINT_SPACE + _OUT << "\"pDrmFormatModifiers\":" << std::endl; + PRINT_SPACE + if (obj.pDrmFormatModifiers) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.drmFormatModifierCount; i++) { + bool isCommaNeeded = (i+1) != obj.drmFormatModifierCount; + print_uint64_t(obj.pDrmFormatModifiers[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->drmFormatModifierCount, "drmFormatModifierCount", 1); + + PRINT_SPACE + _OUT << "\"pDrmFormatModifiers\":" << std::endl; + PRINT_SPACE + if (obj->pDrmFormatModifiers) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->drmFormatModifierCount; i++) { + bool isCommaNeeded = (i+1) != obj->drmFormatModifierCount; + print_uint64_t(obj->pDrmFormatModifiers[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageDrmFormatModifierExplicitCreateInfoEXT(VkImageDrmFormatModifierExplicitCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint64_t(obj.drmFormatModifier, "drmFormatModifier", 1); + + print_uint32_t(obj.drmFormatModifierPlaneCount, "drmFormatModifierPlaneCount", 1); + + PRINT_SPACE + _OUT << "\"pPlaneLayouts\": " << std::endl; + if (obj.pPlaneLayouts) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.drmFormatModifierPlaneCount; i++) { + if (i+1 == obj.drmFormatModifierPlaneCount) + print_VkSubresourceLayout(obj.pPlaneLayouts[i], "pPlaneLayouts", 0); + else + print_VkSubresourceLayout(obj.pPlaneLayouts[i], "pPlaneLayouts", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageDrmFormatModifierExplicitCreateInfoEXT(const VkImageDrmFormatModifierExplicitCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint64_t(obj->drmFormatModifier, "drmFormatModifier", 1); + + print_uint32_t(obj->drmFormatModifierPlaneCount, "drmFormatModifierPlaneCount", 1); + + PRINT_SPACE + _OUT << "\"pPlaneLayouts\": " << std::endl; + if (obj->pPlaneLayouts) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->drmFormatModifierPlaneCount; i++) { + if (i+1 == obj->drmFormatModifierPlaneCount) + print_VkSubresourceLayout(obj->pPlaneLayouts[i], "pPlaneLayouts", 0); + else + print_VkSubresourceLayout(obj->pPlaneLayouts[i], "pPlaneLayouts", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImageDrmFormatModifierPropertiesEXT(VkImageDrmFormatModifierPropertiesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint64_t(obj.drmFormatModifier, "drmFormatModifier", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint64_t(obj->drmFormatModifier, "drmFormatModifier", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDrmFormatModifierProperties2EXT(VkDrmFormatModifierProperties2EXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint64_t(obj.drmFormatModifier, "drmFormatModifier", 1); + + print_uint32_t(obj.drmFormatModifierPlaneCount, "drmFormatModifierPlaneCount", 1); + + print_VkFormatFeatureFlags2KHR(obj.drmFormatModifierTilingFeatures, "drmFormatModifierTilingFeatures", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDrmFormatModifierProperties2EXT(const VkDrmFormatModifierProperties2EXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint64_t(obj->drmFormatModifier, "drmFormatModifier", 1); + + print_uint32_t(obj->drmFormatModifierPlaneCount, "drmFormatModifierPlaneCount", 1); + + print_VkFormatFeatureFlags2KHR(obj->drmFormatModifierTilingFeatures, "drmFormatModifierTilingFeatures", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkDrmFormatModifierPropertiesList2EXT(VkDrmFormatModifierPropertiesList2EXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.drmFormatModifierCount, "drmFormatModifierCount", 1); + + PRINT_SPACE + _OUT << "\"pDrmFormatModifierProperties\": " << std::endl; + if (obj.pDrmFormatModifierProperties) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.drmFormatModifierCount; i++) { + if (i+1 == obj.drmFormatModifierCount) + print_VkDrmFormatModifierProperties2EXT(obj.pDrmFormatModifierProperties[i], "pDrmFormatModifierProperties", 0); + else + print_VkDrmFormatModifierProperties2EXT(obj.pDrmFormatModifierProperties[i], "pDrmFormatModifierProperties", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDrmFormatModifierPropertiesList2EXT(const VkDrmFormatModifierPropertiesList2EXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->drmFormatModifierCount, "drmFormatModifierCount", 1); + + PRINT_SPACE + _OUT << "\"pDrmFormatModifierProperties\": " << std::endl; + if (obj->pDrmFormatModifierProperties) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->drmFormatModifierCount; i++) { + if (i+1 == obj->drmFormatModifierCount) + print_VkDrmFormatModifierProperties2EXT(obj->pDrmFormatModifierProperties[i], "pDrmFormatModifierProperties", 0); + else + print_VkDrmFormatModifierProperties2EXT(obj->pDrmFormatModifierProperties[i], "pDrmFormatModifierProperties", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceImageViewImageFormatInfoEXT(VkPhysicalDeviceImageViewImageFormatInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageViewType(obj.imageViewType, "imageViewType", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceImageViewImageFormatInfoEXT(const VkPhysicalDeviceImageViewImageFormatInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkImageViewType(obj->imageViewType, "imageViewType", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkFilterCubicImageViewImageFormatPropertiesEXT(VkFilterCubicImageViewImageFormatPropertiesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.filterCubic, "filterCubic", 1); + + print_VkBool32(obj.filterCubicMinmax, "filterCubicMinmax", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkFilterCubicImageViewImageFormatPropertiesEXT(const VkFilterCubicImageViewImageFormatPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->filterCubic, "filterCubic", 1); + + print_VkBool32(obj->filterCubicMinmax, "filterCubicMinmax", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static std::map VkQueueGlobalPriorityEXT_map = { + std::make_pair(128, "VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT"), + std::make_pair(256, "VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT"), + std::make_pair(512, "VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT"), + std::make_pair(1024, "VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT"), +}; +static void print_VkQueueGlobalPriorityEXT(VkQueueGlobalPriorityEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkQueueGlobalPriorityEXT_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkQueueGlobalPriorityEXT_map[obj] << "\"" << std::endl; +} +static void print_VkQueueGlobalPriorityEXT(const VkQueueGlobalPriorityEXT * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkQueueGlobalPriorityEXT_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkQueueGlobalPriorityEXT_map[*obj] << "\"" << std::endl; +} + +static void print_VkDeviceQueueGlobalPriorityCreateInfoEXT(VkDeviceQueueGlobalPriorityCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkQueueGlobalPriorityEXT(obj.globalPriority, "globalPriority", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkDeviceQueueGlobalPriorityCreateInfoEXT(const VkDeviceQueueGlobalPriorityCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkQueueGlobalPriorityEXT(obj->globalPriority, "globalPriority", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkImportMemoryHostPointerInfoEXT(VkImportMemoryHostPointerInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalMemoryHandleTypeFlagBits(obj.handleType, "handleType", 1); + + /** Note: Ignoring void* data. **/ + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkImportMemoryHostPointerInfoEXT(const VkImportMemoryHostPointerInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkExternalMemoryHandleTypeFlagBits(obj->handleType, "handleType", 1); + + /** Note: Ignoring void* data. **/ + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkMemoryHostPointerPropertiesEXT(VkMemoryHostPointerPropertiesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.memoryTypeBits, "memoryTypeBits", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkMemoryHostPointerPropertiesEXT(const VkMemoryHostPointerPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->memoryTypeBits, "memoryTypeBits", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(VkPhysicalDeviceExternalMemoryHostPropertiesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceSize(obj.minImportedHostPointerAlignment, "minImportedHostPointerAlignment", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceSize(obj->minImportedHostPointerAlignment, "minImportedHostPointerAlignment", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static std::map VkTimeDomainEXT_map = { + std::make_pair(0, "VK_TIME_DOMAIN_DEVICE_EXT"), + std::make_pair(1, "VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT"), + std::make_pair(2, "VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT"), + std::make_pair(3, "VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT"), +}; +static void print_VkTimeDomainEXT(VkTimeDomainEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkTimeDomainEXT_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkTimeDomainEXT_map[obj] << "\"" << std::endl; +} +static void print_VkTimeDomainEXT(const VkTimeDomainEXT * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkTimeDomainEXT_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkTimeDomainEXT_map[*obj] << "\"" << std::endl; +} + +static void print_VkCalibratedTimestampInfoEXT(VkCalibratedTimestampInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkTimeDomainEXT(obj.timeDomain, "timeDomain", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkCalibratedTimestampInfoEXT(const VkCalibratedTimestampInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkTimeDomainEXT(obj->timeDomain, "timeDomain", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.maxVertexAttribDivisor, "maxVertexAttribDivisor", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->maxVertexAttribDivisor, "maxVertexAttribDivisor", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkVertexInputBindingDivisorDescriptionEXT(VkVertexInputBindingDivisorDescriptionEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj.binding, "binding", 1); + + print_uint32_t(obj.divisor, "divisor", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkVertexInputBindingDivisorDescriptionEXT(const VkVertexInputBindingDivisorDescriptionEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_uint32_t(obj->binding, "binding", 1); + + print_uint32_t(obj->divisor, "divisor", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineVertexInputDivisorStateCreateInfoEXT(VkPipelineVertexInputDivisorStateCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.vertexBindingDivisorCount, "vertexBindingDivisorCount", 1); + + PRINT_SPACE + _OUT << "\"pVertexBindingDivisors\": " << std::endl; + if (obj.pVertexBindingDivisors) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.vertexBindingDivisorCount; i++) { + if (i+1 == obj.vertexBindingDivisorCount) + print_VkVertexInputBindingDivisorDescriptionEXT(obj.pVertexBindingDivisors[i], "pVertexBindingDivisors", 0); + else + print_VkVertexInputBindingDivisorDescriptionEXT(obj.pVertexBindingDivisors[i], "pVertexBindingDivisors", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineVertexInputDivisorStateCreateInfoEXT(const VkPipelineVertexInputDivisorStateCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->vertexBindingDivisorCount, "vertexBindingDivisorCount", 1); + + PRINT_SPACE + _OUT << "\"pVertexBindingDivisors\": " << std::endl; + if (obj->pVertexBindingDivisors) { + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->vertexBindingDivisorCount; i++) { + if (i+1 == obj->vertexBindingDivisorCount) + print_VkVertexInputBindingDivisorDescriptionEXT(obj->pVertexBindingDivisors[i], "pVertexBindingDivisors", 0); + else + print_VkVertexInputBindingDivisorDescriptionEXT(obj->pVertexBindingDivisors[i], "pVertexBindingDivisors", 1); + } + PRINT_SPACE + _OUT << "]" << std::endl; + } + else + { + PRINT_SPACE _OUT << "\"NULL\""<< ""<< std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.vertexAttributeInstanceRateDivisor, "vertexAttributeInstanceRateDivisor", 1); + + print_VkBool32(obj.vertexAttributeInstanceRateZeroDivisor, "vertexAttributeInstanceRateZeroDivisor", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->vertexAttributeInstanceRateDivisor, "vertexAttributeInstanceRateDivisor", 1); + + print_VkBool32(obj->vertexAttributeInstanceRateZeroDivisor, "vertexAttributeInstanceRateZeroDivisor", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDevicePCIBusInfoPropertiesEXT(VkPhysicalDevicePCIBusInfoPropertiesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.pciDomain, "pciDomain", 1); + + print_uint32_t(obj.pciBus, "pciBus", 1); + + print_uint32_t(obj.pciDevice, "pciDevice", 1); + + print_uint32_t(obj.pciFunction, "pciFunction", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDevicePCIBusInfoPropertiesEXT(const VkPhysicalDevicePCIBusInfoPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->pciDomain, "pciDomain", 1); + + print_uint32_t(obj->pciBus, "pciBus", 1); + + print_uint32_t(obj->pciDevice, "pciDevice", 1); + + print_uint32_t(obj->pciFunction, "pciFunction", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(VkPhysicalDeviceSubgroupSizeControlFeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.subgroupSizeControl, "subgroupSizeControl", 1); + + print_VkBool32(obj.computeFullSubgroups, "computeFullSubgroups", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->subgroupSizeControl, "subgroupSizeControl", 1); + + print_VkBool32(obj->computeFullSubgroups, "computeFullSubgroups", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(VkPhysicalDeviceSubgroupSizeControlPropertiesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.minSubgroupSize, "minSubgroupSize", 1); + + print_uint32_t(obj.maxSubgroupSize, "maxSubgroupSize", 1); + + print_uint32_t(obj.maxComputeWorkgroupSubgroups, "maxComputeWorkgroupSubgroups", 1); + + print_VkShaderStageFlags(obj.requiredSubgroupSizeStages, "requiredSubgroupSizeStages", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->minSubgroupSize, "minSubgroupSize", 1); + + print_uint32_t(obj->maxSubgroupSize, "maxSubgroupSize", 1); + + print_uint32_t(obj->maxComputeWorkgroupSubgroups, "maxComputeWorkgroupSubgroups", 1); + + print_VkShaderStageFlags(obj->requiredSubgroupSizeStages, "requiredSubgroupSizeStages", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.requiredSubgroupSize, "requiredSubgroupSize", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->requiredSubgroupSize, "requiredSubgroupSize", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.shaderImageInt64Atomics, "shaderImageInt64Atomics", 1); + + print_VkBool32(obj.sparseImageInt64Atomics, "sparseImageInt64Atomics", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->shaderImageInt64Atomics, "shaderImageInt64Atomics", 1); + + print_VkBool32(obj->sparseImageInt64Atomics, "sparseImageInt64Atomics", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceMemoryBudgetPropertiesEXT(VkPhysicalDeviceMemoryBudgetPropertiesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"heapBudget\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_MEMORY_HEAPS; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_MEMORY_HEAPS; + print_VkDeviceSize(obj.heapBudget[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"heapUsage\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_MEMORY_HEAPS; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_MEMORY_HEAPS; + print_VkDeviceSize(obj.heapUsage[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const VkPhysicalDeviceMemoryBudgetPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + PRINT_SPACE + _OUT << "\"heapBudget\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_MEMORY_HEAPS; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_MEMORY_HEAPS; + print_VkDeviceSize(obj->heapBudget[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + + PRINT_SPACE + _OUT << "\"heapUsage\":" << std::endl; + PRINT_SPACE + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < VK_MAX_MEMORY_HEAPS; i++) { + bool isCommaNeeded = (i+1) != VK_MAX_MEMORY_HEAPS; + print_VkDeviceSize(obj->heapUsage[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static std::map VkValidationFeatureEnableEXT_map = { + std::make_pair(0, "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT"), + std::make_pair(1, "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT"), + std::make_pair(2, "VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT"), + std::make_pair(3, "VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT"), + std::make_pair(4, "VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT"), +}; +static void print_VkValidationFeatureEnableEXT(VkValidationFeatureEnableEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkValidationFeatureEnableEXT_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkValidationFeatureEnableEXT_map[obj] << "\"" << std::endl; +} +static void print_VkValidationFeatureEnableEXT(const VkValidationFeatureEnableEXT * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkValidationFeatureEnableEXT_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkValidationFeatureEnableEXT_map[*obj] << "\"" << std::endl; +} + +static std::map VkValidationFeatureDisableEXT_map = { + std::make_pair(0, "VK_VALIDATION_FEATURE_DISABLE_ALL_EXT"), + std::make_pair(1, "VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT"), + std::make_pair(2, "VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT"), + std::make_pair(3, "VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT"), + std::make_pair(4, "VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT"), + std::make_pair(5, "VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT"), + std::make_pair(6, "VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT"), + std::make_pair(7, "VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT"), +}; +static void print_VkValidationFeatureDisableEXT(VkValidationFeatureDisableEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkValidationFeatureDisableEXT_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkValidationFeatureDisableEXT_map[obj] << "\"" << std::endl; +} +static void print_VkValidationFeatureDisableEXT(const VkValidationFeatureDisableEXT * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkValidationFeatureDisableEXT_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkValidationFeatureDisableEXT_map[*obj] << "\"" << std::endl; +} + +static void print_VkValidationFeaturesEXT(VkValidationFeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.enabledValidationFeatureCount, "enabledValidationFeatureCount", 1); + + PRINT_SPACE + _OUT << "\"pEnabledValidationFeatures\":" << std::endl; + PRINT_SPACE + if (obj.pEnabledValidationFeatures) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.enabledValidationFeatureCount; i++) { + bool isCommaNeeded = (i+1) != obj.enabledValidationFeatureCount; + print_VkValidationFeatureEnableEXT(obj.pEnabledValidationFeatures[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj.disabledValidationFeatureCount, "disabledValidationFeatureCount", 1); + + PRINT_SPACE + _OUT << "\"pDisabledValidationFeatures\":" << std::endl; + PRINT_SPACE + if (obj.pDisabledValidationFeatures) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.disabledValidationFeatureCount; i++) { + bool isCommaNeeded = (i+1) != obj.disabledValidationFeatureCount; + print_VkValidationFeatureDisableEXT(obj.pDisabledValidationFeatures[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkValidationFeaturesEXT(const VkValidationFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->enabledValidationFeatureCount, "enabledValidationFeatureCount", 1); + + PRINT_SPACE + _OUT << "\"pEnabledValidationFeatures\":" << std::endl; + PRINT_SPACE + if (obj->pEnabledValidationFeatures) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->enabledValidationFeatureCount; i++) { + bool isCommaNeeded = (i+1) != obj->enabledValidationFeatureCount; + print_VkValidationFeatureEnableEXT(obj->pEnabledValidationFeatures[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "," << std::endl; + } else { + _OUT << "\"NULL\"" << "," << std::endl; + } + + print_uint32_t(obj->disabledValidationFeatureCount, "disabledValidationFeatureCount", 1); + + PRINT_SPACE + _OUT << "\"pDisabledValidationFeatures\":" << std::endl; + PRINT_SPACE + if (obj->pDisabledValidationFeatures) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->disabledValidationFeatureCount; i++) { + bool isCommaNeeded = (i+1) != obj->disabledValidationFeatureCount; + print_VkValidationFeatureDisableEXT(obj->pDisabledValidationFeatures[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.fragmentShaderSampleInterlock, "fragmentShaderSampleInterlock", 1); + + print_VkBool32(obj.fragmentShaderPixelInterlock, "fragmentShaderPixelInterlock", 1); + + print_VkBool32(obj.fragmentShaderShadingRateInterlock, "fragmentShaderShadingRateInterlock", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->fragmentShaderSampleInterlock, "fragmentShaderSampleInterlock", 1); + + print_VkBool32(obj->fragmentShaderPixelInterlock, "fragmentShaderPixelInterlock", 1); + + print_VkBool32(obj->fragmentShaderShadingRateInterlock, "fragmentShaderShadingRateInterlock", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.ycbcrImageArrays, "ycbcrImageArrays", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->ycbcrImageArrays, "ycbcrImageArrays", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkHeadlessSurfaceCreateFlagsEXT(VkHeadlessSurfaceCreateFlagsEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl; + else + _OUT << "\"" << str << "\"" << " : " << obj << std::endl; +} +static void print_VkHeadlessSurfaceCreateFlagsEXT(const VkHeadlessSurfaceCreateFlagsEXT * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (commaNeeded) + _OUT << "\"" << str << "\"" << " : " << obj << "," << std::endl; + else + _OUT << "\"" << str << "\"" << " : " << obj << std::endl; +} + +static void print_VkHeadlessSurfaceCreateInfoEXT(VkHeadlessSurfaceCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkHeadlessSurfaceCreateFlagsEXT(obj.flags, "flags", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkHeadlessSurfaceCreateInfoEXT(const VkHeadlessSurfaceCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkHeadlessSurfaceCreateFlagsEXT(obj->flags, "flags", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static std::map VkLineRasterizationModeEXT_map = { + std::make_pair(0, "VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT"), + std::make_pair(1, "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT"), + std::make_pair(2, "VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT"), + std::make_pair(3, "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT"), +}; +static void print_VkLineRasterizationModeEXT(VkLineRasterizationModeEXT obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkLineRasterizationModeEXT_map[obj] << "\"," << std::endl; + else + _OUT << "\"" << VkLineRasterizationModeEXT_map[obj] << "\"" << std::endl; +} +static void print_VkLineRasterizationModeEXT(const VkLineRasterizationModeEXT * obj, const std::string& str, bool commaNeeded=true) { + PRINT_SPACE + if (str != "") _OUT << "\"" << str << "\"" << " : "; + if (commaNeeded) + _OUT << "\"" << VkLineRasterizationModeEXT_map[*obj] << "\"," << std::endl; + else + _OUT << "\"" << VkLineRasterizationModeEXT_map[*obj] << "\"" << std::endl; +} + +static void print_VkPhysicalDeviceLineRasterizationFeaturesEXT(VkPhysicalDeviceLineRasterizationFeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.rectangularLines, "rectangularLines", 1); + + print_VkBool32(obj.bresenhamLines, "bresenhamLines", 1); + + print_VkBool32(obj.smoothLines, "smoothLines", 1); + + print_VkBool32(obj.stippledRectangularLines, "stippledRectangularLines", 1); + + print_VkBool32(obj.stippledBresenhamLines, "stippledBresenhamLines", 1); + + print_VkBool32(obj.stippledSmoothLines, "stippledSmoothLines", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceLineRasterizationFeaturesEXT(const VkPhysicalDeviceLineRasterizationFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->rectangularLines, "rectangularLines", 1); + + print_VkBool32(obj->bresenhamLines, "bresenhamLines", 1); + + print_VkBool32(obj->smoothLines, "smoothLines", 1); + + print_VkBool32(obj->stippledRectangularLines, "stippledRectangularLines", 1); + + print_VkBool32(obj->stippledBresenhamLines, "stippledBresenhamLines", 1); + + print_VkBool32(obj->stippledSmoothLines, "stippledSmoothLines", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceLineRasterizationPropertiesEXT(VkPhysicalDeviceLineRasterizationPropertiesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.lineSubPixelPrecisionBits, "lineSubPixelPrecisionBits", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceLineRasterizationPropertiesEXT(const VkPhysicalDeviceLineRasterizationPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->lineSubPixelPrecisionBits, "lineSubPixelPrecisionBits", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineRasterizationLineStateCreateInfoEXT(VkPipelineRasterizationLineStateCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkLineRasterizationModeEXT(obj.lineRasterizationMode, "lineRasterizationMode", 1); + + print_VkBool32(obj.stippledLineEnable, "stippledLineEnable", 1); + + print_uint32_t(obj.lineStippleFactor, "lineStippleFactor", 1); + + print_uint16_t(obj.lineStipplePattern, "lineStipplePattern", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineRasterizationLineStateCreateInfoEXT(const VkPipelineRasterizationLineStateCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkLineRasterizationModeEXT(obj->lineRasterizationMode, "lineRasterizationMode", 1); + + print_VkBool32(obj->stippledLineEnable, "stippledLineEnable", 1); + + print_uint32_t(obj->lineStippleFactor, "lineStippleFactor", 1); + + print_uint16_t(obj->lineStipplePattern, "lineStipplePattern", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.shaderBufferFloat32Atomics, "shaderBufferFloat32Atomics", 1); + + print_VkBool32(obj.shaderBufferFloat32AtomicAdd, "shaderBufferFloat32AtomicAdd", 1); + + print_VkBool32(obj.shaderBufferFloat64Atomics, "shaderBufferFloat64Atomics", 1); + + print_VkBool32(obj.shaderBufferFloat64AtomicAdd, "shaderBufferFloat64AtomicAdd", 1); + + print_VkBool32(obj.shaderSharedFloat32Atomics, "shaderSharedFloat32Atomics", 1); + + print_VkBool32(obj.shaderSharedFloat32AtomicAdd, "shaderSharedFloat32AtomicAdd", 1); + + print_VkBool32(obj.shaderSharedFloat64Atomics, "shaderSharedFloat64Atomics", 1); + + print_VkBool32(obj.shaderSharedFloat64AtomicAdd, "shaderSharedFloat64AtomicAdd", 1); + + print_VkBool32(obj.shaderImageFloat32Atomics, "shaderImageFloat32Atomics", 1); + + print_VkBool32(obj.shaderImageFloat32AtomicAdd, "shaderImageFloat32AtomicAdd", 1); + + print_VkBool32(obj.sparseImageFloat32Atomics, "sparseImageFloat32Atomics", 1); + + print_VkBool32(obj.sparseImageFloat32AtomicAdd, "sparseImageFloat32AtomicAdd", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->shaderBufferFloat32Atomics, "shaderBufferFloat32Atomics", 1); + + print_VkBool32(obj->shaderBufferFloat32AtomicAdd, "shaderBufferFloat32AtomicAdd", 1); + + print_VkBool32(obj->shaderBufferFloat64Atomics, "shaderBufferFloat64Atomics", 1); + + print_VkBool32(obj->shaderBufferFloat64AtomicAdd, "shaderBufferFloat64AtomicAdd", 1); + + print_VkBool32(obj->shaderSharedFloat32Atomics, "shaderSharedFloat32Atomics", 1); + + print_VkBool32(obj->shaderSharedFloat32AtomicAdd, "shaderSharedFloat32AtomicAdd", 1); + + print_VkBool32(obj->shaderSharedFloat64Atomics, "shaderSharedFloat64Atomics", 1); + + print_VkBool32(obj->shaderSharedFloat64AtomicAdd, "shaderSharedFloat64AtomicAdd", 1); + + print_VkBool32(obj->shaderImageFloat32Atomics, "shaderImageFloat32Atomics", 1); + + print_VkBool32(obj->shaderImageFloat32AtomicAdd, "shaderImageFloat32AtomicAdd", 1); + + print_VkBool32(obj->sparseImageFloat32Atomics, "sparseImageFloat32Atomics", 1); + + print_VkBool32(obj->sparseImageFloat32AtomicAdd, "sparseImageFloat32AtomicAdd", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(VkPhysicalDeviceIndexTypeUint8FeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.indexTypeUint8, "indexTypeUint8", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->indexTypeUint8, "indexTypeUint8", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.extendedDynamicState, "extendedDynamicState", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->extendedDynamicState, "extendedDynamicState", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.shaderDemoteToHelperInvocation, "shaderDemoteToHelperInvocation", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->shaderDemoteToHelperInvocation, "shaderDemoteToHelperInvocation", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.texelBufferAlignment, "texelBufferAlignment", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->texelBufferAlignment, "texelBufferAlignment", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceSize(obj.storageTexelBufferOffsetAlignmentBytes, "storageTexelBufferOffsetAlignmentBytes", 1); + + print_VkBool32(obj.storageTexelBufferOffsetSingleTexelAlignment, "storageTexelBufferOffsetSingleTexelAlignment", 1); + + print_VkDeviceSize(obj.uniformTexelBufferOffsetAlignmentBytes, "uniformTexelBufferOffsetAlignmentBytes", 1); + + print_VkBool32(obj.uniformTexelBufferOffsetSingleTexelAlignment, "uniformTexelBufferOffsetSingleTexelAlignment", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceSize(obj->storageTexelBufferOffsetAlignmentBytes, "storageTexelBufferOffsetAlignmentBytes", 1); + + print_VkBool32(obj->storageTexelBufferOffsetSingleTexelAlignment, "storageTexelBufferOffsetSingleTexelAlignment", 1); + + print_VkDeviceSize(obj->uniformTexelBufferOffsetAlignmentBytes, "uniformTexelBufferOffsetAlignmentBytes", 1); + + print_VkBool32(obj->uniformTexelBufferOffsetSingleTexelAlignment, "uniformTexelBufferOffsetSingleTexelAlignment", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceRobustness2FeaturesEXT(VkPhysicalDeviceRobustness2FeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.robustBufferAccess2, "robustBufferAccess2", 1); + + print_VkBool32(obj.robustImageAccess2, "robustImageAccess2", 1); + + print_VkBool32(obj.nullDescriptor, "nullDescriptor", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceRobustness2FeaturesEXT(const VkPhysicalDeviceRobustness2FeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->robustBufferAccess2, "robustBufferAccess2", 1); + + print_VkBool32(obj->robustImageAccess2, "robustImageAccess2", 1); + + print_VkBool32(obj->nullDescriptor, "nullDescriptor", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceRobustness2PropertiesEXT(VkPhysicalDeviceRobustness2PropertiesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceSize(obj.robustStorageBufferAccessSizeAlignment, "robustStorageBufferAccessSizeAlignment", 1); + + print_VkDeviceSize(obj.robustUniformBufferAccessSizeAlignment, "robustUniformBufferAccessSizeAlignment", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceRobustness2PropertiesEXT(const VkPhysicalDeviceRobustness2PropertiesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkDeviceSize(obj->robustStorageBufferAccessSizeAlignment, "robustStorageBufferAccessSizeAlignment", 1); + + print_VkDeviceSize(obj->robustUniformBufferAccessSizeAlignment, "robustUniformBufferAccessSizeAlignment", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkSamplerCustomBorderColorCreateInfoEXT(VkSamplerCustomBorderColorCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkClearColorValue(obj.customBorderColor, "customBorderColor", 1); + + print_VkFormat(obj.format, "format", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkSamplerCustomBorderColorCreateInfoEXT(const VkSamplerCustomBorderColorCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkClearColorValue(obj->customBorderColor, "customBorderColor", 1); + + print_VkFormat(obj->format, "format", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceCustomBorderColorPropertiesEXT(VkPhysicalDeviceCustomBorderColorPropertiesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.maxCustomBorderColorSamplers, "maxCustomBorderColorSamplers", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const VkPhysicalDeviceCustomBorderColorPropertiesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->maxCustomBorderColorSamplers, "maxCustomBorderColorSamplers", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceCustomBorderColorFeaturesEXT(VkPhysicalDeviceCustomBorderColorFeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.customBorderColors, "customBorderColors", 1); + + print_VkBool32(obj.customBorderColorWithoutFormat, "customBorderColorWithoutFormat", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const VkPhysicalDeviceCustomBorderColorFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->customBorderColors, "customBorderColors", 1); + + print_VkBool32(obj->customBorderColorWithoutFormat, "customBorderColorWithoutFormat", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.ycbcr2plane444Formats, "ycbcr2plane444Formats", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->ycbcr2plane444Formats, "ycbcr2plane444Formats", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceImageRobustnessFeaturesEXT(VkPhysicalDeviceImageRobustnessFeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.robustImageAccess, "robustImageAccess", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceImageRobustnessFeaturesEXT(const VkPhysicalDeviceImageRobustnessFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->robustImageAccess, "robustImageAccess", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDevice4444FormatsFeaturesEXT(VkPhysicalDevice4444FormatsFeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.formatA4R4G4B4, "formatA4R4G4B4", 1); + + print_VkBool32(obj.formatA4B4G4R4, "formatA4B4G4R4", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDevice4444FormatsFeaturesEXT(const VkPhysicalDevice4444FormatsFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->formatA4R4G4B4, "formatA4R4G4B4", 1); + + print_VkBool32(obj->formatA4B4G4R4, "formatA4B4G4R4", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.vertexInputDynamicState, "vertexInputDynamicState", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->vertexInputDynamicState, "vertexInputDynamicState", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkVertexInputBindingDescription2EXT(VkVertexInputBindingDescription2EXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.binding, "binding", 1); + + print_uint32_t(obj.stride, "stride", 1); + + print_VkVertexInputRate(obj.inputRate, "inputRate", 1); + + print_uint32_t(obj.divisor, "divisor", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkVertexInputBindingDescription2EXT(const VkVertexInputBindingDescription2EXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->binding, "binding", 1); + + print_uint32_t(obj->stride, "stride", 1); + + print_VkVertexInputRate(obj->inputRate, "inputRate", 1); + + print_uint32_t(obj->divisor, "divisor", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkVertexInputAttributeDescription2EXT(VkVertexInputAttributeDescription2EXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.location, "location", 1); + + print_uint32_t(obj.binding, "binding", 1); + + print_VkFormat(obj.format, "format", 1); + + print_uint32_t(obj.offset, "offset", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkVertexInputAttributeDescription2EXT(const VkVertexInputAttributeDescription2EXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->location, "location", 1); + + print_uint32_t(obj->binding, "binding", 1); + + print_VkFormat(obj->format, "format", 1); + + print_uint32_t(obj->offset, "offset", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.extendedDynamicState2, "extendedDynamicState2", 1); + + print_VkBool32(obj.extendedDynamicState2LogicOp, "extendedDynamicState2LogicOp", 1); + + print_VkBool32(obj.extendedDynamicState2PatchControlPoints, "extendedDynamicState2PatchControlPoints", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->extendedDynamicState2, "extendedDynamicState2", 1); + + print_VkBool32(obj->extendedDynamicState2LogicOp, "extendedDynamicState2LogicOp", 1); + + print_VkBool32(obj->extendedDynamicState2PatchControlPoints, "extendedDynamicState2PatchControlPoints", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPhysicalDeviceColorWriteEnableFeaturesEXT(VkPhysicalDeviceColorWriteEnableFeaturesEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj.colorWriteEnable, "colorWriteEnable", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPhysicalDeviceColorWriteEnableFeaturesEXT(const VkPhysicalDeviceColorWriteEnableFeaturesEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_VkBool32(obj->colorWriteEnable, "colorWriteEnable", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkPipelineColorWriteCreateInfoEXT(VkPipelineColorWriteCreateInfoEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.attachmentCount, "attachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pColorWriteEnables\":" << std::endl; + PRINT_SPACE + if (obj.pColorWriteEnables) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj.attachmentCount; i++) { + bool isCommaNeeded = (i+1) != obj.attachmentCount; + print_VkBool32(obj.pColorWriteEnables[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkPipelineColorWriteCreateInfoEXT(const VkPipelineColorWriteCreateInfoEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->attachmentCount, "attachmentCount", 1); + + PRINT_SPACE + _OUT << "\"pColorWriteEnables\":" << std::endl; + PRINT_SPACE + if (obj->pColorWriteEnables) { + _OUT << "[" << std::endl; + for (unsigned int i = 0; i < obj->attachmentCount; i++) { + bool isCommaNeeded = (i+1) != obj->attachmentCount; + print_VkBool32(obj->pColorWriteEnables[i], "", isCommaNeeded); + } + PRINT_SPACE + _OUT << "]" << "" << std::endl; + } else { + _OUT << "\"NULL\"" << "" << std::endl; + } + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +static void print_VkApplicationParametersEXT(VkApplicationParametersEXT obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj.sType, "sType", 1); + + if (obj.pNext) { + dumpPNextChain(obj.pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj.vendorID, "vendorID", 1); + + print_uint32_t(obj.deviceID, "deviceID", 1); + + print_uint32_t(obj.key, "key", 1); + + print_uint64_t(obj.value, "value", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} +static void print_VkApplicationParametersEXT(const VkApplicationParametersEXT * obj, const std::string& s, bool commaNeeded=true) { + PRINT_SPACE + _OUT << "{" << std::endl; + INDENT(4); + + print_VkStructureType(obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + _OUT << "\"pNext\":" << "\"NULL\""<< ","<< std::endl; + } + + print_uint32_t(obj->vendorID, "vendorID", 1); + + print_uint32_t(obj->deviceID, "deviceID", 1); + + print_uint32_t(obj->key, "key", 1); + + print_uint64_t(obj->value, "value", 0); + + INDENT(-4); + PRINT_SPACE + if (commaNeeded) + _OUT << "}," << std::endl; + else + _OUT << "}" << std::endl; +} + +/*************************************** Begin prototypes ***********************************/ +/*************************************** End prototypes ***********************************/ + +static void dumpPNextChain(const void* pNext) { + VkBaseInStructure *pBase = (VkBaseInStructure*)pNext; + if (pNext) { + PRINT_SPACE + _OUT << "\"pNext\":"<< std::endl; + + switch (pBase->sType) { + case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:print_VkDisplayPresentInfoKHR((VkDisplayPresentInfoKHR *) pNext, "VkDisplayPresentInfoKHR", true); + break; + case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:print_VkValidationFeaturesEXT((VkValidationFeaturesEXT *) pNext, "VkValidationFeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT:print_VkApplicationParametersEXT((VkApplicationParametersEXT *) pNext, "VkApplicationParametersEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:print_VkPhysicalDeviceFeatures2((VkPhysicalDeviceFeatures2 *) pNext, "VkPhysicalDeviceFeatures2", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:print_VkPhysicalDeviceDriverProperties((VkPhysicalDeviceDriverProperties *) pNext, "VkPhysicalDeviceDriverProperties", true); + break; + case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:print_VkPresentRegionsKHR((VkPresentRegionsKHR *) pNext, "VkPresentRegionsKHR", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:print_VkPhysicalDeviceVariablePointersFeatures((VkPhysicalDeviceVariablePointersFeatures *) pNext, "VkPhysicalDeviceVariablePointersFeatures", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:print_VkPhysicalDeviceExternalImageFormatInfo((VkPhysicalDeviceExternalImageFormatInfo *) pNext, "VkPhysicalDeviceExternalImageFormatInfo", true); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:print_VkExternalImageFormatProperties((VkExternalImageFormatProperties *) pNext, "VkExternalImageFormatProperties", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:print_VkPhysicalDeviceIDProperties((VkPhysicalDeviceIDProperties *) pNext, "VkPhysicalDeviceIDProperties", true); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:print_VkExternalMemoryImageCreateInfo((VkExternalMemoryImageCreateInfo *) pNext, "VkExternalMemoryImageCreateInfo", true); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:print_VkExternalMemoryBufferCreateInfo((VkExternalMemoryBufferCreateInfo *) pNext, "VkExternalMemoryBufferCreateInfo", true); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:print_VkExportMemoryAllocateInfo((VkExportMemoryAllocateInfo *) pNext, "VkExportMemoryAllocateInfo", true); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:print_VkImportMemoryFdInfoKHR((VkImportMemoryFdInfoKHR *) pNext, "VkImportMemoryFdInfoKHR", true); + break; + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:print_VkExportSemaphoreCreateInfo((VkExportSemaphoreCreateInfo *) pNext, "VkExportSemaphoreCreateInfo", true); + break; + case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:print_VkExportFenceCreateInfo((VkExportFenceCreateInfo *) pNext, "VkExportFenceCreateInfo", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:print_VkPhysicalDeviceMultiviewFeatures((VkPhysicalDeviceMultiviewFeatures *) pNext, "VkPhysicalDeviceMultiviewFeatures", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:print_VkPhysicalDeviceMultiviewProperties((VkPhysicalDeviceMultiviewProperties *) pNext, "VkPhysicalDeviceMultiviewProperties", true); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:print_VkRenderPassMultiviewCreateInfo((VkRenderPassMultiviewCreateInfo *) pNext, "VkRenderPassMultiviewCreateInfo", true); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:print_VkSwapchainCounterCreateInfoEXT((VkSwapchainCounterCreateInfoEXT *) pNext, "VkSwapchainCounterCreateInfoEXT", true); + break; + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:print_VkMemoryAllocateFlagsInfo((VkMemoryAllocateFlagsInfo *) pNext, "VkMemoryAllocateFlagsInfo", true); + break; + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:print_VkBindBufferMemoryDeviceGroupInfo((VkBindBufferMemoryDeviceGroupInfo *) pNext, "VkBindBufferMemoryDeviceGroupInfo", true); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:print_VkBindImageMemoryDeviceGroupInfo((VkBindImageMemoryDeviceGroupInfo *) pNext, "VkBindImageMemoryDeviceGroupInfo", true); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:print_VkDeviceGroupRenderPassBeginInfo((VkDeviceGroupRenderPassBeginInfo *) pNext, "VkDeviceGroupRenderPassBeginInfo", true); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:print_VkDeviceGroupCommandBufferBeginInfo((VkDeviceGroupCommandBufferBeginInfo *) pNext, "VkDeviceGroupCommandBufferBeginInfo", true); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:print_VkDeviceGroupSubmitInfo((VkDeviceGroupSubmitInfo *) pNext, "VkDeviceGroupSubmitInfo", true); + break; + case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:print_VkImageSwapchainCreateInfoKHR((VkImageSwapchainCreateInfoKHR *) pNext, "VkImageSwapchainCreateInfoKHR", true); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:print_VkBindImageMemorySwapchainInfoKHR((VkBindImageMemorySwapchainInfoKHR *) pNext, "VkBindImageMemorySwapchainInfoKHR", true); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:print_VkDeviceGroupPresentInfoKHR((VkDeviceGroupPresentInfoKHR *) pNext, "VkDeviceGroupPresentInfoKHR", true); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:print_VkDeviceGroupDeviceCreateInfo((VkDeviceGroupDeviceCreateInfo *) pNext, "VkDeviceGroupDeviceCreateInfo", true); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:print_VkDeviceGroupSwapchainCreateInfoKHR((VkDeviceGroupSwapchainCreateInfoKHR *) pNext, "VkDeviceGroupSwapchainCreateInfoKHR", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:print_VkPhysicalDeviceDiscardRectanglePropertiesEXT((VkPhysicalDeviceDiscardRectanglePropertiesEXT *) pNext, "VkPhysicalDeviceDiscardRectanglePropertiesEXT", true); + break; + case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:print_VkPipelineDiscardRectangleStateCreateInfoEXT((VkPipelineDiscardRectangleStateCreateInfoEXT *) pNext, "VkPipelineDiscardRectangleStateCreateInfoEXT", true); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:print_VkRenderPassInputAttachmentAspectCreateInfo((VkRenderPassInputAttachmentAspectCreateInfo *) pNext, "VkRenderPassInputAttachmentAspectCreateInfo", true); + break; + case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:print_VkSharedPresentSurfaceCapabilitiesKHR((VkSharedPresentSurfaceCapabilitiesKHR *) pNext, "VkSharedPresentSurfaceCapabilitiesKHR", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:print_VkPhysicalDevice16BitStorageFeatures((VkPhysicalDevice16BitStorageFeatures *) pNext, "VkPhysicalDevice16BitStorageFeatures", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:print_VkPhysicalDeviceSubgroupProperties((VkPhysicalDeviceSubgroupProperties *) pNext, "VkPhysicalDeviceSubgroupProperties", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:print_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures((VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *) pNext, "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:print_VkPhysicalDevicePointClippingProperties((VkPhysicalDevicePointClippingProperties *) pNext, "VkPhysicalDevicePointClippingProperties", true); + break; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:print_VkMemoryDedicatedRequirements((VkMemoryDedicatedRequirements *) pNext, "VkMemoryDedicatedRequirements", true); + break; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:print_VkMemoryDedicatedAllocateInfo((VkMemoryDedicatedAllocateInfo *) pNext, "VkMemoryDedicatedAllocateInfo", true); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:print_VkImageViewUsageCreateInfo((VkImageViewUsageCreateInfo *) pNext, "VkImageViewUsageCreateInfo", true); + break; + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:print_VkPipelineTessellationDomainOriginStateCreateInfo((VkPipelineTessellationDomainOriginStateCreateInfo *) pNext, "VkPipelineTessellationDomainOriginStateCreateInfo", true); + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:print_VkSamplerYcbcrConversionInfo((VkSamplerYcbcrConversionInfo *) pNext, "VkSamplerYcbcrConversionInfo", true); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:print_VkBindImagePlaneMemoryInfo((VkBindImagePlaneMemoryInfo *) pNext, "VkBindImagePlaneMemoryInfo", true); + break; + case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:print_VkImagePlaneMemoryRequirementsInfo((VkImagePlaneMemoryRequirementsInfo *) pNext, "VkImagePlaneMemoryRequirementsInfo", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:print_VkPhysicalDeviceSamplerYcbcrConversionFeatures((VkPhysicalDeviceSamplerYcbcrConversionFeatures *) pNext, "VkPhysicalDeviceSamplerYcbcrConversionFeatures", true); + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:print_VkSamplerYcbcrConversionImageFormatProperties((VkSamplerYcbcrConversionImageFormatProperties *) pNext, "VkSamplerYcbcrConversionImageFormatProperties", true); + break; + case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:print_VkProtectedSubmitInfo((VkProtectedSubmitInfo *) pNext, "VkProtectedSubmitInfo", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:print_VkPhysicalDeviceProtectedMemoryFeatures((VkPhysicalDeviceProtectedMemoryFeatures *) pNext, "VkPhysicalDeviceProtectedMemoryFeatures", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:print_VkPhysicalDeviceProtectedMemoryProperties((VkPhysicalDeviceProtectedMemoryProperties *) pNext, "VkPhysicalDeviceProtectedMemoryProperties", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:print_VkPhysicalDeviceSamplerFilterMinmaxProperties((VkPhysicalDeviceSamplerFilterMinmaxProperties *) pNext, "VkPhysicalDeviceSamplerFilterMinmaxProperties", true); + break; + case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:print_VkSampleLocationsInfoEXT((VkSampleLocationsInfoEXT *) pNext, "VkSampleLocationsInfoEXT", true); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:print_VkRenderPassSampleLocationsBeginInfoEXT((VkRenderPassSampleLocationsBeginInfoEXT *) pNext, "VkRenderPassSampleLocationsBeginInfoEXT", true); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:print_VkPipelineSampleLocationsStateCreateInfoEXT((VkPipelineSampleLocationsStateCreateInfoEXT *) pNext, "VkPipelineSampleLocationsStateCreateInfoEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:print_VkPhysicalDeviceSampleLocationsPropertiesEXT((VkPhysicalDeviceSampleLocationsPropertiesEXT *) pNext, "VkPhysicalDeviceSampleLocationsPropertiesEXT", true); + break; + case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:print_VkSamplerReductionModeCreateInfo((VkSamplerReductionModeCreateInfo *) pNext, "VkSamplerReductionModeCreateInfo", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:print_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT((VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *) pNext, "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:print_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT((VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *) pNext, "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT", true); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:print_VkPipelineColorBlendAdvancedStateCreateInfoEXT((VkPipelineColorBlendAdvancedStateCreateInfoEXT *) pNext, "VkPipelineColorBlendAdvancedStateCreateInfoEXT", true); + break; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:print_VkImageFormatListCreateInfo((VkImageFormatListCreateInfo *) pNext, "VkImageFormatListCreateInfo", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:print_VkPhysicalDeviceMaintenance3Properties((VkPhysicalDeviceMaintenance3Properties *) pNext, "VkPhysicalDeviceMaintenance3Properties", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:print_VkPhysicalDeviceShaderDrawParametersFeatures((VkPhysicalDeviceShaderDrawParametersFeatures *) pNext, "VkPhysicalDeviceShaderDrawParametersFeatures", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:print_VkPhysicalDeviceShaderFloat16Int8Features((VkPhysicalDeviceShaderFloat16Int8Features *) pNext, "VkPhysicalDeviceShaderFloat16Int8Features", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:print_VkPhysicalDeviceFloatControlsProperties((VkPhysicalDeviceFloatControlsProperties *) pNext, "VkPhysicalDeviceFloatControlsProperties", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:print_VkPhysicalDeviceHostQueryResetFeatures((VkPhysicalDeviceHostQueryResetFeatures *) pNext, "VkPhysicalDeviceHostQueryResetFeatures", true); + break; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:print_VkDeviceQueueGlobalPriorityCreateInfoEXT((VkDeviceQueueGlobalPriorityCreateInfoEXT *) pNext, "VkDeviceQueueGlobalPriorityCreateInfoEXT", true); + break; + case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:print_VkDebugUtilsMessengerCreateInfoEXT((VkDebugUtilsMessengerCreateInfoEXT *) pNext, "VkDebugUtilsMessengerCreateInfoEXT", true); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:print_VkImportMemoryHostPointerInfoEXT((VkImportMemoryHostPointerInfoEXT *) pNext, "VkImportMemoryHostPointerInfoEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:print_VkPhysicalDeviceExternalMemoryHostPropertiesEXT((VkPhysicalDeviceExternalMemoryHostPropertiesEXT *) pNext, "VkPhysicalDeviceExternalMemoryHostPropertiesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:print_VkPhysicalDeviceConservativeRasterizationPropertiesEXT((VkPhysicalDeviceConservativeRasterizationPropertiesEXT *) pNext, "VkPhysicalDeviceConservativeRasterizationPropertiesEXT", true); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:print_VkPipelineRasterizationConservativeStateCreateInfoEXT((VkPipelineRasterizationConservativeStateCreateInfoEXT *) pNext, "VkPipelineRasterizationConservativeStateCreateInfoEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:print_VkPhysicalDeviceDescriptorIndexingFeatures((VkPhysicalDeviceDescriptorIndexingFeatures *) pNext, "VkPhysicalDeviceDescriptorIndexingFeatures", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:print_VkPhysicalDeviceDescriptorIndexingProperties((VkPhysicalDeviceDescriptorIndexingProperties *) pNext, "VkPhysicalDeviceDescriptorIndexingProperties", true); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:print_VkDescriptorSetLayoutBindingFlagsCreateInfo((VkDescriptorSetLayoutBindingFlagsCreateInfo *) pNext, "VkDescriptorSetLayoutBindingFlagsCreateInfo", true); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:print_VkDescriptorSetVariableDescriptorCountAllocateInfo((VkDescriptorSetVariableDescriptorCountAllocateInfo *) pNext, "VkDescriptorSetVariableDescriptorCountAllocateInfo", true); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:print_VkDescriptorSetVariableDescriptorCountLayoutSupport((VkDescriptorSetVariableDescriptorCountLayoutSupport *) pNext, "VkDescriptorSetVariableDescriptorCountLayoutSupport", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:print_VkPhysicalDeviceTimelineSemaphoreFeatures((VkPhysicalDeviceTimelineSemaphoreFeatures *) pNext, "VkPhysicalDeviceTimelineSemaphoreFeatures", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:print_VkPhysicalDeviceTimelineSemaphoreProperties((VkPhysicalDeviceTimelineSemaphoreProperties *) pNext, "VkPhysicalDeviceTimelineSemaphoreProperties", true); + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:print_VkSemaphoreTypeCreateInfo((VkSemaphoreTypeCreateInfo *) pNext, "VkSemaphoreTypeCreateInfo", true); + break; + case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:print_VkTimelineSemaphoreSubmitInfo((VkTimelineSemaphoreSubmitInfo *) pNext, "VkTimelineSemaphoreSubmitInfo", true); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:print_VkPipelineVertexInputDivisorStateCreateInfoEXT((VkPipelineVertexInputDivisorStateCreateInfoEXT *) pNext, "VkPipelineVertexInputDivisorStateCreateInfoEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:print_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT((VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *) pNext, "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:print_VkPhysicalDevicePCIBusInfoPropertiesEXT((VkPhysicalDevicePCIBusInfoPropertiesEXT *) pNext, "VkPhysicalDevicePCIBusInfoPropertiesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:print_VkPhysicalDevice8BitStorageFeatures((VkPhysicalDevice8BitStorageFeatures *) pNext, "VkPhysicalDevice8BitStorageFeatures", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:print_VkPhysicalDeviceVulkanMemoryModelFeatures((VkPhysicalDeviceVulkanMemoryModelFeatures *) pNext, "VkPhysicalDeviceVulkanMemoryModelFeatures", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:print_VkPhysicalDeviceShaderAtomicInt64Features((VkPhysicalDeviceShaderAtomicInt64Features *) pNext, "VkPhysicalDeviceShaderAtomicInt64Features", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:print_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT((VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *) pNext, "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:print_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT((VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *) pNext, "VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:print_VkPhysicalDeviceDepthStencilResolveProperties((VkPhysicalDeviceDepthStencilResolveProperties *) pNext, "VkPhysicalDeviceDepthStencilResolveProperties", true); + break; + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:print_VkSubpassDescriptionDepthStencilResolve((VkSubpassDescriptionDepthStencilResolve *) pNext, "VkSubpassDescriptionDepthStencilResolve", true); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:print_VkImageViewASTCDecodeModeEXT((VkImageViewASTCDecodeModeEXT *) pNext, "VkImageViewASTCDecodeModeEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:print_VkPhysicalDeviceASTCDecodeFeaturesEXT((VkPhysicalDeviceASTCDecodeFeaturesEXT *) pNext, "VkPhysicalDeviceASTCDecodeFeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:print_VkDrmFormatModifierPropertiesListEXT((VkDrmFormatModifierPropertiesListEXT *) pNext, "VkDrmFormatModifierPropertiesListEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:print_VkPhysicalDeviceImageDrmFormatModifierInfoEXT((VkPhysicalDeviceImageDrmFormatModifierInfoEXT *) pNext, "VkPhysicalDeviceImageDrmFormatModifierInfoEXT", true); + break; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:print_VkImageDrmFormatModifierListCreateInfoEXT((VkImageDrmFormatModifierListCreateInfoEXT *) pNext, "VkImageDrmFormatModifierListCreateInfoEXT", true); + break; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:print_VkImageDrmFormatModifierExplicitCreateInfoEXT((VkImageDrmFormatModifierExplicitCreateInfoEXT *) pNext, "VkImageDrmFormatModifierExplicitCreateInfoEXT", true); + break; + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:print_VkImageStencilUsageCreateInfo((VkImageStencilUsageCreateInfo *) pNext, "VkImageStencilUsageCreateInfo", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:print_VkPhysicalDeviceScalarBlockLayoutFeatures((VkPhysicalDeviceScalarBlockLayoutFeatures *) pNext, "VkPhysicalDeviceScalarBlockLayoutFeatures", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:print_VkPhysicalDeviceUniformBufferStandardLayoutFeatures((VkPhysicalDeviceUniformBufferStandardLayoutFeatures *) pNext, "VkPhysicalDeviceUniformBufferStandardLayoutFeatures", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:print_VkPhysicalDeviceDepthClipEnableFeaturesEXT((VkPhysicalDeviceDepthClipEnableFeaturesEXT *) pNext, "VkPhysicalDeviceDepthClipEnableFeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:print_VkPipelineRasterizationDepthClipStateCreateInfoEXT((VkPipelineRasterizationDepthClipStateCreateInfoEXT *) pNext, "VkPipelineRasterizationDepthClipStateCreateInfoEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:print_VkPhysicalDeviceMemoryBudgetPropertiesEXT((VkPhysicalDeviceMemoryBudgetPropertiesEXT *) pNext, "VkPhysicalDeviceMemoryBudgetPropertiesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:print_VkPhysicalDeviceBufferDeviceAddressFeatures((VkPhysicalDeviceBufferDeviceAddressFeatures *) pNext, "VkPhysicalDeviceBufferDeviceAddressFeatures", true); + break; + case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:print_VkBufferOpaqueCaptureAddressCreateInfo((VkBufferOpaqueCaptureAddressCreateInfo *) pNext, "VkBufferOpaqueCaptureAddressCreateInfo", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:print_VkPhysicalDeviceImageViewImageFormatInfoEXT((VkPhysicalDeviceImageViewImageFormatInfoEXT *) pNext, "VkPhysicalDeviceImageViewImageFormatInfoEXT", true); + break; + case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:print_VkFilterCubicImageViewImageFormatPropertiesEXT((VkFilterCubicImageViewImageFormatPropertiesEXT *) pNext, "VkFilterCubicImageViewImageFormatPropertiesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:print_VkPhysicalDeviceImagelessFramebufferFeatures((VkPhysicalDeviceImagelessFramebufferFeatures *) pNext, "VkPhysicalDeviceImagelessFramebufferFeatures", true); + break; + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:print_VkFramebufferAttachmentsCreateInfo((VkFramebufferAttachmentsCreateInfo *) pNext, "VkFramebufferAttachmentsCreateInfo", true); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:print_VkRenderPassAttachmentBeginInfo((VkRenderPassAttachmentBeginInfo *) pNext, "VkRenderPassAttachmentBeginInfo", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:print_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT((VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *) pNext, "VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:print_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT((VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *) pNext, "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:print_VkPhysicalDevicePerformanceQueryFeaturesKHR((VkPhysicalDevicePerformanceQueryFeaturesKHR *) pNext, "VkPhysicalDevicePerformanceQueryFeaturesKHR", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:print_VkPhysicalDevicePerformanceQueryPropertiesKHR((VkPhysicalDevicePerformanceQueryPropertiesKHR *) pNext, "VkPhysicalDevicePerformanceQueryPropertiesKHR", true); + break; + case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:print_VkQueryPoolPerformanceCreateInfoKHR((VkQueryPoolPerformanceCreateInfoKHR *) pNext, "VkQueryPoolPerformanceCreateInfoKHR", true); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:print_VkPerformanceQuerySubmitInfoKHR((VkPerformanceQuerySubmitInfoKHR *) pNext, "VkPerformanceQuerySubmitInfoKHR", true); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR:print_VkPerformanceQueryReservationInfoKHR((VkPerformanceQueryReservationInfoKHR *) pNext, "VkPerformanceQueryReservationInfoKHR", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:print_VkPhysicalDeviceShaderClockFeaturesKHR((VkPhysicalDeviceShaderClockFeaturesKHR *) pNext, "VkPhysicalDeviceShaderClockFeaturesKHR", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:print_VkPhysicalDeviceIndexTypeUint8FeaturesEXT((VkPhysicalDeviceIndexTypeUint8FeaturesEXT *) pNext, "VkPhysicalDeviceIndexTypeUint8FeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:print_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT((VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *) pNext, "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:print_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures((VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *) pNext, "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures", true); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:print_VkAttachmentReferenceStencilLayout((VkAttachmentReferenceStencilLayout *) pNext, "VkAttachmentReferenceStencilLayout", true); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:print_VkAttachmentDescriptionStencilLayout((VkAttachmentDescriptionStencilLayout *) pNext, "VkAttachmentDescriptionStencilLayout", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:print_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT((VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *) pNext, "VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:print_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT((VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *) pNext, "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:print_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT((VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *) pNext, "VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:print_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT((VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *) pNext, "VkPhysicalDeviceSubgroupSizeControlFeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:print_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT((VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *) pNext, "VkPhysicalDeviceSubgroupSizeControlPropertiesEXT", true); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:print_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT((VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *) pNext, "VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT", true); + break; + case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:print_VkMemoryOpaqueCaptureAddressAllocateInfo((VkMemoryOpaqueCaptureAddressAllocateInfo *) pNext, "VkMemoryOpaqueCaptureAddressAllocateInfo", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:print_VkPhysicalDeviceLineRasterizationFeaturesEXT((VkPhysicalDeviceLineRasterizationFeaturesEXT *) pNext, "VkPhysicalDeviceLineRasterizationFeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:print_VkPhysicalDeviceLineRasterizationPropertiesEXT((VkPhysicalDeviceLineRasterizationPropertiesEXT *) pNext, "VkPhysicalDeviceLineRasterizationPropertiesEXT", true); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:print_VkPipelineRasterizationLineStateCreateInfoEXT((VkPipelineRasterizationLineStateCreateInfoEXT *) pNext, "VkPipelineRasterizationLineStateCreateInfoEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:print_VkPhysicalDeviceVulkan11Features((VkPhysicalDeviceVulkan11Features *) pNext, "VkPhysicalDeviceVulkan11Features", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:print_VkPhysicalDeviceVulkan11Properties((VkPhysicalDeviceVulkan11Properties *) pNext, "VkPhysicalDeviceVulkan11Properties", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:print_VkPhysicalDeviceVulkan12Features((VkPhysicalDeviceVulkan12Features *) pNext, "VkPhysicalDeviceVulkan12Features", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:print_VkPhysicalDeviceVulkan12Properties((VkPhysicalDeviceVulkan12Properties *) pNext, "VkPhysicalDeviceVulkan12Properties", true); + break; + case VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO:print_VkFaultCallbackInfo((VkFaultCallbackInfo *) pNext, "VkFaultCallbackInfo", true); + break; + case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:print_VkSamplerCustomBorderColorCreateInfoEXT((VkSamplerCustomBorderColorCreateInfoEXT *) pNext, "VkSamplerCustomBorderColorCreateInfoEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:print_VkPhysicalDeviceCustomBorderColorPropertiesEXT((VkPhysicalDeviceCustomBorderColorPropertiesEXT *) pNext, "VkPhysicalDeviceCustomBorderColorPropertiesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:print_VkPhysicalDeviceCustomBorderColorFeaturesEXT((VkPhysicalDeviceCustomBorderColorFeaturesEXT *) pNext, "VkPhysicalDeviceCustomBorderColorFeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:print_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT((VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *) pNext, "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:print_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT((VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *) pNext, "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO:print_VkPipelineOfflineCreateInfo((VkPipelineOfflineCreateInfo *) pNext, "VkPipelineOfflineCreateInfo", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:print_VkPhysicalDeviceRobustness2FeaturesEXT((VkPhysicalDeviceRobustness2FeaturesEXT *) pNext, "VkPhysicalDeviceRobustness2FeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:print_VkPhysicalDeviceRobustness2PropertiesEXT((VkPhysicalDeviceRobustness2PropertiesEXT *) pNext, "VkPhysicalDeviceRobustness2PropertiesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:print_VkPhysicalDeviceImageRobustnessFeaturesEXT((VkPhysicalDeviceImageRobustnessFeaturesEXT *) pNext, "VkPhysicalDeviceImageRobustnessFeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:print_VkPhysicalDevice4444FormatsFeaturesEXT((VkPhysicalDevice4444FormatsFeaturesEXT *) pNext, "VkPhysicalDevice4444FormatsFeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:print_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT((VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *) pNext, "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:print_VkFragmentShadingRateAttachmentInfoKHR((VkFragmentShadingRateAttachmentInfoKHR *) pNext, "VkFragmentShadingRateAttachmentInfoKHR", true); + break; + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:print_VkPipelineFragmentShadingRateStateCreateInfoKHR((VkPipelineFragmentShadingRateStateCreateInfoKHR *) pNext, "VkPipelineFragmentShadingRateStateCreateInfoKHR", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:print_VkPhysicalDeviceFragmentShadingRateFeaturesKHR((VkPhysicalDeviceFragmentShadingRateFeaturesKHR *) pNext, "VkPhysicalDeviceFragmentShadingRateFeaturesKHR", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:print_VkPhysicalDeviceFragmentShadingRatePropertiesKHR((VkPhysicalDeviceFragmentShadingRatePropertiesKHR *) pNext, "VkPhysicalDeviceFragmentShadingRatePropertiesKHR", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR:print_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR((VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *) pNext, "VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:print_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT((VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *) pNext, "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:print_VkPhysicalDeviceColorWriteEnableFeaturesEXT((VkPhysicalDeviceColorWriteEnableFeaturesEXT *) pNext, "VkPhysicalDeviceColorWriteEnableFeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:print_VkPipelineColorWriteCreateInfoEXT((VkPipelineColorWriteCreateInfoEXT *) pNext, "VkPipelineColorWriteCreateInfoEXT", true); + break; + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR:print_VkMemoryBarrier2KHR((VkMemoryBarrier2KHR *) pNext, "VkMemoryBarrier2KHR", true); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:print_VkQueueFamilyCheckpointProperties2NV((VkQueueFamilyCheckpointProperties2NV *) pNext, "VkQueueFamilyCheckpointProperties2NV", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR:print_VkPhysicalDeviceSynchronization2FeaturesKHR((VkPhysicalDeviceSynchronization2FeaturesKHR *) pNext, "VkPhysicalDeviceSynchronization2FeaturesKHR", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES:print_VkPhysicalDeviceVulkanSC10Properties((VkPhysicalDeviceVulkanSC10Properties *) pNext, "VkPhysicalDeviceVulkanSC10Properties", true); + break; + case VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO:print_VkDeviceObjectReservationCreateInfo((VkDeviceObjectReservationCreateInfo *) pNext, "VkDeviceObjectReservationCreateInfo", true); + break; + case VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO:print_VkCommandPoolMemoryReservationCreateInfo((VkCommandPoolMemoryReservationCreateInfo *) pNext, "VkCommandPoolMemoryReservationCreateInfo", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES:print_VkPhysicalDeviceVulkanSC10Features((VkPhysicalDeviceVulkanSC10Features *) pNext, "VkPhysicalDeviceVulkanSC10Features", true); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:print_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT((VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *) pNext, "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT", true); + break; + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:print_VkDrmFormatModifierPropertiesList2EXT((VkDrmFormatModifierPropertiesList2EXT *) pNext, "VkDrmFormatModifierPropertiesList2EXT", true); + break; + default: assert(false); // No structure type matching + } + } + } + +}//End of namespace vk_json + +#endif // _VULKAN_JSON_DATA_HPP \ No newline at end of file diff --git a/json/vulkan_json_gen.c b/json/vulkan_json_gen.c new file mode 100644 index 0000000..05c7aec --- /dev/null +++ b/json/vulkan_json_gen.c @@ -0,0 +1,20787 @@ + +/* +** Copyright (c) 2020 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + + +/********************************************************************************************/ +/** This code is generated. To make changes, please modify the scripts or the relevant xml **/ +/********************************************************************************************/ + +#pragma once + +#include +#include +#include +#include +#include +#include "vulkan_json_gen.h" + +#define MAX_SIZE 255 // We don't expect to write a bigger string at a time. +#define MAX_JSON_SIZE 1024*1024 // We don't expect the entire JSON file to be bigger than this. + +static int s_num_spaces = 0; +static char s_tempBuf[MAX_SIZE]; +static char s_outBuf[MAX_JSON_SIZE]; +static char *s_writePtr = s_outBuf; + +#define _OUT s_tempBuf + +#define UPDATE_BUF strncpy(s_writePtr, s_tempBuf, strnlen(s_tempBuf, MAX_SIZE)); s_writePtr += strnlen(s_tempBuf, MAX_SIZE); + +// Variadic macro for neat buffer update + print. +#define vk_json_printf(...) { sprintf(__VA_ARGS__); UPDATE_BUF } + +// Helper utility to do indentation in the generated json file. +#define PRINT_SPACE { int i; for (i = 0; i < s_num_spaces; i++) vk_json_printf(_OUT, " "); } + + +#define INDENT(sz) s_num_spaces += (sz); + +const char* getJSONOutput() +{ + return s_outBuf; +} + +void resetJSONOutput(void) +{ + memset(s_outBuf, 0x00, MAX_JSON_SIZE); + s_writePtr = s_outBuf; +} + + + +void print_int32_t(const int32_t * obj, const char* s, int commaNeeded) { + PRINT_SPACE + if (s[0] != 0) { + vk_json_printf(_OUT, "\"%s\" : %d%s\n", s, *obj, commaNeeded ? "," : ""); + } else { + vk_json_printf(_OUT, "%d%s\n", *obj, commaNeeded ? "," : ""); + } +} + + +void print_uint32_t(const uint32_t * obj, const char* s, int commaNeeded) { + PRINT_SPACE + if (s[0] != 0) { + vk_json_printf(_OUT, "\"%s\" : %u%s\n", s, *obj, commaNeeded ? "," : ""); + } else { + vk_json_printf(_OUT, "%u%s\n", *obj, commaNeeded ? "," : ""); + } +} + + +void print_uint8_t(const uint8_t * obj, const char* s, int commaNeeded) { + PRINT_SPACE + if (s[0] != 0) { + vk_json_printf(_OUT, "\"%s\" : %u%s\n", s, *obj, commaNeeded ? "," : ""); + } else { + vk_json_printf(_OUT, "%u%s\n", *obj, commaNeeded ? "," : ""); + } +} + + +void print_uint64_t(const uint64_t * obj, const char* s, int commaNeeded) { + PRINT_SPACE + if (s[0] != 0) { + vk_json_printf(_OUT, "\"%s\" : %" PRIu64 "%s\n", s, *obj, commaNeeded ? "," : ""); + } else { + vk_json_printf(_OUT, "%" PRIu64 "%s\n", *obj, commaNeeded ? "," : ""); + } +} + + +void print_float(const float * obj, const char* s, int commaNeeded) { + PRINT_SPACE + if (s[0] != 0) { + vk_json_printf(_OUT, "\"%s\" : %f%s\n", s, *obj, commaNeeded ? "," : ""); + } else { + vk_json_printf(_OUT, "%f%s\n", *obj, commaNeeded ? "," : ""); + } +} + + +void print_int(const int * obj, const char* s, int commaNeeded) { + PRINT_SPACE + if (s[0] != 0) { + vk_json_printf(_OUT, "\"%s\" : %d%s\n", s, *obj, commaNeeded ? "," : ""); + } else { + vk_json_printf(_OUT, "%d%s\n", *obj, commaNeeded ? "," : ""); + } +} + + +void print_double(const double * obj, const char* s, int commaNeeded) { + PRINT_SPACE + if (s[0] != 0) { + vk_json_printf(_OUT, "\"%s\" : %lf%s\n", s, *obj, commaNeeded ? "," : ""); + } else { + vk_json_printf(_OUT, "%lf%s\n", *obj, commaNeeded ? "," : ""); + } +} + + +void print_int64_t(const int64_t * obj, const char* s, int commaNeeded) { + PRINT_SPACE + if (s[0] != 0) { + vk_json_printf(_OUT, "\"%s\" : %" PRId64 "%s\n", s, *obj, commaNeeded ? "," : ""); + } else { + vk_json_printf(_OUT, "%" PRId64 "%s\n", *obj, commaNeeded ? "," : ""); + } +} + + +void print_uint16_t(const uint16_t * obj, const char* s, int commaNeeded) { + PRINT_SPACE + if (s[0] != 0) { + vk_json_printf(_OUT, "\"%s\" : %u%s\n", s, *obj, commaNeeded ? "," : ""); + } else { + vk_json_printf(_OUT, "%u%s\n", *obj, commaNeeded ? "," : ""); + } +} + + +void print_char(const char * obj, const char* s, int commaNeeded) { + PRINT_SPACE + if (s[0] != 0) { + vk_json_printf(_OUT, "\"%s\" : %c%s\n", s, *obj, commaNeeded ? "," : ""); + } else { + vk_json_printf(_OUT, "%c%s\n", *obj, commaNeeded ? "," : ""); + } +} + + +void print_size_t(const size_t * obj, const char* s, int commaNeeded) { + PRINT_SPACE + if (s[0] != 0) { + vk_json_printf(_OUT, "\"%s\" : %zu%s\n", s, *obj, commaNeeded ? "," : ""); + } else { + vk_json_printf(_OUT, "%zu%s\n", *obj, commaNeeded ? "," : ""); + } +} + +void dumpPNextChain(const void* pNext) { + VkBaseInStructure *pBase = (VkBaseInStructure*)pNext; + if (pNext) { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\":\n"); + switch (pBase->sType) { +#ifdef VK_KHR_display_swapchain + case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:print_VkDisplayPresentInfoKHR(((VkDisplayPresentInfoKHR *)pNext), "VkDisplayPresentInfoKHR", 1); + break; +#endif +#ifdef VK_EXT_validation_features + case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:print_VkValidationFeaturesEXT(((VkValidationFeaturesEXT *)pNext), "VkValidationFeaturesEXT", 1); + break; +#endif +#ifdef VK_EXT_application_parameters + case VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT:print_VkApplicationParametersEXT(((VkApplicationParametersEXT *)pNext), "VkApplicationParametersEXT", 1); + break; +#endif +#ifdef VK_VERSION_1_1 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:print_VkPhysicalDeviceFeatures2(((VkPhysicalDeviceFeatures2 *)pNext), "VkPhysicalDeviceFeatures2", 1); + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:print_VkPhysicalDeviceDriverProperties(((VkPhysicalDeviceDriverProperties *)pNext), "VkPhysicalDeviceDriverProperties", 1); + break; +#endif +#ifdef VK_KHR_incremental_present + case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:print_VkPresentRegionsKHR(((VkPresentRegionsKHR *)pNext), "VkPresentRegionsKHR", 1); + break; +#endif +#ifdef VK_VERSION_1_1 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:print_VkPhysicalDeviceVariablePointersFeatures(((VkPhysicalDeviceVariablePointersFeatures *)pNext), "VkPhysicalDeviceVariablePointersFeatures", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:print_VkPhysicalDeviceExternalImageFormatInfo(((VkPhysicalDeviceExternalImageFormatInfo *)pNext), "VkPhysicalDeviceExternalImageFormatInfo", 1); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:print_VkExternalImageFormatProperties(((VkExternalImageFormatProperties *)pNext), "VkExternalImageFormatProperties", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:print_VkPhysicalDeviceIDProperties(((VkPhysicalDeviceIDProperties *)pNext), "VkPhysicalDeviceIDProperties", 1); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:print_VkExternalMemoryImageCreateInfo(((VkExternalMemoryImageCreateInfo *)pNext), "VkExternalMemoryImageCreateInfo", 1); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:print_VkExternalMemoryBufferCreateInfo(((VkExternalMemoryBufferCreateInfo *)pNext), "VkExternalMemoryBufferCreateInfo", 1); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:print_VkExportMemoryAllocateInfo(((VkExportMemoryAllocateInfo *)pNext), "VkExportMemoryAllocateInfo", 1); + break; +#endif +#ifdef VK_KHR_external_memory_fd + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:print_VkImportMemoryFdInfoKHR(((VkImportMemoryFdInfoKHR *)pNext), "VkImportMemoryFdInfoKHR", 1); + break; +#endif +#ifdef VK_VERSION_1_1 + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:print_VkExportSemaphoreCreateInfo(((VkExportSemaphoreCreateInfo *)pNext), "VkExportSemaphoreCreateInfo", 1); + break; + case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:print_VkExportFenceCreateInfo(((VkExportFenceCreateInfo *)pNext), "VkExportFenceCreateInfo", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:print_VkPhysicalDeviceMultiviewFeatures(((VkPhysicalDeviceMultiviewFeatures *)pNext), "VkPhysicalDeviceMultiviewFeatures", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:print_VkPhysicalDeviceMultiviewProperties(((VkPhysicalDeviceMultiviewProperties *)pNext), "VkPhysicalDeviceMultiviewProperties", 1); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:print_VkRenderPassMultiviewCreateInfo(((VkRenderPassMultiviewCreateInfo *)pNext), "VkRenderPassMultiviewCreateInfo", 1); + break; +#endif +#ifdef VK_EXT_display_control + case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:print_VkSwapchainCounterCreateInfoEXT(((VkSwapchainCounterCreateInfoEXT *)pNext), "VkSwapchainCounterCreateInfoEXT", 1); + break; +#endif +#ifdef VK_VERSION_1_1 + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:print_VkMemoryAllocateFlagsInfo(((VkMemoryAllocateFlagsInfo *)pNext), "VkMemoryAllocateFlagsInfo", 1); + break; + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:print_VkBindBufferMemoryDeviceGroupInfo(((VkBindBufferMemoryDeviceGroupInfo *)pNext), "VkBindBufferMemoryDeviceGroupInfo", 1); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:print_VkBindImageMemoryDeviceGroupInfo(((VkBindImageMemoryDeviceGroupInfo *)pNext), "VkBindImageMemoryDeviceGroupInfo", 1); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:print_VkDeviceGroupRenderPassBeginInfo(((VkDeviceGroupRenderPassBeginInfo *)pNext), "VkDeviceGroupRenderPassBeginInfo", 1); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:print_VkDeviceGroupCommandBufferBeginInfo(((VkDeviceGroupCommandBufferBeginInfo *)pNext), "VkDeviceGroupCommandBufferBeginInfo", 1); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:print_VkDeviceGroupSubmitInfo(((VkDeviceGroupSubmitInfo *)pNext), "VkDeviceGroupSubmitInfo", 1); + break; +#endif +#ifdef VK_KHR_swapchain + case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:print_VkImageSwapchainCreateInfoKHR(((VkImageSwapchainCreateInfoKHR *)pNext), "VkImageSwapchainCreateInfoKHR", 1); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:print_VkBindImageMemorySwapchainInfoKHR(((VkBindImageMemorySwapchainInfoKHR *)pNext), "VkBindImageMemorySwapchainInfoKHR", 1); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:print_VkDeviceGroupPresentInfoKHR(((VkDeviceGroupPresentInfoKHR *)pNext), "VkDeviceGroupPresentInfoKHR", 1); + break; +#endif +#ifdef VK_VERSION_1_1 + case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:print_VkDeviceGroupDeviceCreateInfo(((VkDeviceGroupDeviceCreateInfo *)pNext), "VkDeviceGroupDeviceCreateInfo", 1); + break; +#endif +#ifdef VK_KHR_swapchain + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:print_VkDeviceGroupSwapchainCreateInfoKHR(((VkDeviceGroupSwapchainCreateInfoKHR *)pNext), "VkDeviceGroupSwapchainCreateInfoKHR", 1); + break; +#endif +#ifdef VK_EXT_discard_rectangles + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:print_VkPhysicalDeviceDiscardRectanglePropertiesEXT(((VkPhysicalDeviceDiscardRectanglePropertiesEXT *)pNext), "VkPhysicalDeviceDiscardRectanglePropertiesEXT", 1); + break; + case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:print_VkPipelineDiscardRectangleStateCreateInfoEXT(((VkPipelineDiscardRectangleStateCreateInfoEXT *)pNext), "VkPipelineDiscardRectangleStateCreateInfoEXT", 1); + break; +#endif +#ifdef VK_VERSION_1_1 + case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:print_VkRenderPassInputAttachmentAspectCreateInfo(((VkRenderPassInputAttachmentAspectCreateInfo *)pNext), "VkRenderPassInputAttachmentAspectCreateInfo", 1); + break; +#endif +#ifdef VK_KHR_shared_presentable_image + case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:print_VkSharedPresentSurfaceCapabilitiesKHR(((VkSharedPresentSurfaceCapabilitiesKHR *)pNext), "VkSharedPresentSurfaceCapabilitiesKHR", 1); + break; +#endif +#ifdef VK_VERSION_1_1 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:print_VkPhysicalDevice16BitStorageFeatures(((VkPhysicalDevice16BitStorageFeatures *)pNext), "VkPhysicalDevice16BitStorageFeatures", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:print_VkPhysicalDeviceSubgroupProperties(((VkPhysicalDeviceSubgroupProperties *)pNext), "VkPhysicalDeviceSubgroupProperties", 1); + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:print_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(((VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pNext), "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures", 1); + break; +#endif +#ifdef VK_VERSION_1_1 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:print_VkPhysicalDevicePointClippingProperties(((VkPhysicalDevicePointClippingProperties *)pNext), "VkPhysicalDevicePointClippingProperties", 1); + break; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:print_VkMemoryDedicatedRequirements(((VkMemoryDedicatedRequirements *)pNext), "VkMemoryDedicatedRequirements", 1); + break; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:print_VkMemoryDedicatedAllocateInfo(((VkMemoryDedicatedAllocateInfo *)pNext), "VkMemoryDedicatedAllocateInfo", 1); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:print_VkImageViewUsageCreateInfo(((VkImageViewUsageCreateInfo *)pNext), "VkImageViewUsageCreateInfo", 1); + break; + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:print_VkPipelineTessellationDomainOriginStateCreateInfo(((VkPipelineTessellationDomainOriginStateCreateInfo *)pNext), "VkPipelineTessellationDomainOriginStateCreateInfo", 1); + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:print_VkSamplerYcbcrConversionInfo(((VkSamplerYcbcrConversionInfo *)pNext), "VkSamplerYcbcrConversionInfo", 1); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:print_VkBindImagePlaneMemoryInfo(((VkBindImagePlaneMemoryInfo *)pNext), "VkBindImagePlaneMemoryInfo", 1); + break; + case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:print_VkImagePlaneMemoryRequirementsInfo(((VkImagePlaneMemoryRequirementsInfo *)pNext), "VkImagePlaneMemoryRequirementsInfo", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:print_VkPhysicalDeviceSamplerYcbcrConversionFeatures(((VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pNext), "VkPhysicalDeviceSamplerYcbcrConversionFeatures", 1); + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:print_VkSamplerYcbcrConversionImageFormatProperties(((VkSamplerYcbcrConversionImageFormatProperties *)pNext), "VkSamplerYcbcrConversionImageFormatProperties", 1); + break; + case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:print_VkProtectedSubmitInfo(((VkProtectedSubmitInfo *)pNext), "VkProtectedSubmitInfo", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:print_VkPhysicalDeviceProtectedMemoryFeatures(((VkPhysicalDeviceProtectedMemoryFeatures *)pNext), "VkPhysicalDeviceProtectedMemoryFeatures", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:print_VkPhysicalDeviceProtectedMemoryProperties(((VkPhysicalDeviceProtectedMemoryProperties *)pNext), "VkPhysicalDeviceProtectedMemoryProperties", 1); + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:print_VkPhysicalDeviceSamplerFilterMinmaxProperties(((VkPhysicalDeviceSamplerFilterMinmaxProperties *)pNext), "VkPhysicalDeviceSamplerFilterMinmaxProperties", 1); + break; +#endif +#ifdef VK_EXT_sample_locations + case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:print_VkSampleLocationsInfoEXT(((VkSampleLocationsInfoEXT *)pNext), "VkSampleLocationsInfoEXT", 1); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:print_VkRenderPassSampleLocationsBeginInfoEXT(((VkRenderPassSampleLocationsBeginInfoEXT *)pNext), "VkRenderPassSampleLocationsBeginInfoEXT", 1); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:print_VkPipelineSampleLocationsStateCreateInfoEXT(((VkPipelineSampleLocationsStateCreateInfoEXT *)pNext), "VkPipelineSampleLocationsStateCreateInfoEXT", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:print_VkPhysicalDeviceSampleLocationsPropertiesEXT(((VkPhysicalDeviceSampleLocationsPropertiesEXT *)pNext), "VkPhysicalDeviceSampleLocationsPropertiesEXT", 1); + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:print_VkSamplerReductionModeCreateInfo(((VkSamplerReductionModeCreateInfo *)pNext), "VkSamplerReductionModeCreateInfo", 1); + break; +#endif +#ifdef VK_EXT_blend_operation_advanced + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:print_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(((VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)pNext), "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:print_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(((VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *)pNext), "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT", 1); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:print_VkPipelineColorBlendAdvancedStateCreateInfoEXT(((VkPipelineColorBlendAdvancedStateCreateInfoEXT *)pNext), "VkPipelineColorBlendAdvancedStateCreateInfoEXT", 1); + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:print_VkImageFormatListCreateInfo(((VkImageFormatListCreateInfo *)pNext), "VkImageFormatListCreateInfo", 1); + break; +#endif +#ifdef VK_VERSION_1_1 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:print_VkPhysicalDeviceMaintenance3Properties(((VkPhysicalDeviceMaintenance3Properties *)pNext), "VkPhysicalDeviceMaintenance3Properties", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:print_VkPhysicalDeviceShaderDrawParametersFeatures(((VkPhysicalDeviceShaderDrawParametersFeatures *)pNext), "VkPhysicalDeviceShaderDrawParametersFeatures", 1); + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:print_VkPhysicalDeviceShaderFloat16Int8Features(((VkPhysicalDeviceShaderFloat16Int8Features *)pNext), "VkPhysicalDeviceShaderFloat16Int8Features", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:print_VkPhysicalDeviceFloatControlsProperties(((VkPhysicalDeviceFloatControlsProperties *)pNext), "VkPhysicalDeviceFloatControlsProperties", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:print_VkPhysicalDeviceHostQueryResetFeatures(((VkPhysicalDeviceHostQueryResetFeatures *)pNext), "VkPhysicalDeviceHostQueryResetFeatures", 1); + break; +#endif +#ifdef VK_EXT_global_priority + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:print_VkDeviceQueueGlobalPriorityCreateInfoEXT(((VkDeviceQueueGlobalPriorityCreateInfoEXT *)pNext), "VkDeviceQueueGlobalPriorityCreateInfoEXT", 1); + break; +#endif +#ifdef VK_EXT_debug_utils + case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:print_VkDebugUtilsMessengerCreateInfoEXT(((VkDebugUtilsMessengerCreateInfoEXT *)pNext), "VkDebugUtilsMessengerCreateInfoEXT", 1); + break; +#endif +#ifdef VK_EXT_external_memory_host + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:print_VkImportMemoryHostPointerInfoEXT(((VkImportMemoryHostPointerInfoEXT *)pNext), "VkImportMemoryHostPointerInfoEXT", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:print_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(((VkPhysicalDeviceExternalMemoryHostPropertiesEXT *)pNext), "VkPhysicalDeviceExternalMemoryHostPropertiesEXT", 1); + break; +#endif +#ifdef VK_EXT_conservative_rasterization + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:print_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(((VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)pNext), "VkPhysicalDeviceConservativeRasterizationPropertiesEXT", 1); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:print_VkPipelineRasterizationConservativeStateCreateInfoEXT(((VkPipelineRasterizationConservativeStateCreateInfoEXT *)pNext), "VkPipelineRasterizationConservativeStateCreateInfoEXT", 1); + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:print_VkPhysicalDeviceDescriptorIndexingFeatures(((VkPhysicalDeviceDescriptorIndexingFeatures *)pNext), "VkPhysicalDeviceDescriptorIndexingFeatures", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:print_VkPhysicalDeviceDescriptorIndexingProperties(((VkPhysicalDeviceDescriptorIndexingProperties *)pNext), "VkPhysicalDeviceDescriptorIndexingProperties", 1); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:print_VkDescriptorSetLayoutBindingFlagsCreateInfo(((VkDescriptorSetLayoutBindingFlagsCreateInfo *)pNext), "VkDescriptorSetLayoutBindingFlagsCreateInfo", 1); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:print_VkDescriptorSetVariableDescriptorCountAllocateInfo(((VkDescriptorSetVariableDescriptorCountAllocateInfo *)pNext), "VkDescriptorSetVariableDescriptorCountAllocateInfo", 1); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:print_VkDescriptorSetVariableDescriptorCountLayoutSupport(((VkDescriptorSetVariableDescriptorCountLayoutSupport *)pNext), "VkDescriptorSetVariableDescriptorCountLayoutSupport", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:print_VkPhysicalDeviceTimelineSemaphoreFeatures(((VkPhysicalDeviceTimelineSemaphoreFeatures *)pNext), "VkPhysicalDeviceTimelineSemaphoreFeatures", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:print_VkPhysicalDeviceTimelineSemaphoreProperties(((VkPhysicalDeviceTimelineSemaphoreProperties *)pNext), "VkPhysicalDeviceTimelineSemaphoreProperties", 1); + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:print_VkSemaphoreTypeCreateInfo(((VkSemaphoreTypeCreateInfo *)pNext), "VkSemaphoreTypeCreateInfo", 1); + break; + case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:print_VkTimelineSemaphoreSubmitInfo(((VkTimelineSemaphoreSubmitInfo *)pNext), "VkTimelineSemaphoreSubmitInfo", 1); + break; +#endif +#ifdef VK_EXT_vertex_attribute_divisor + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:print_VkPipelineVertexInputDivisorStateCreateInfoEXT(((VkPipelineVertexInputDivisorStateCreateInfoEXT *)pNext), "VkPipelineVertexInputDivisorStateCreateInfoEXT", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:print_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(((VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)pNext), "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT", 1); + break; +#endif +#ifdef VK_EXT_pci_bus_info + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:print_VkPhysicalDevicePCIBusInfoPropertiesEXT(((VkPhysicalDevicePCIBusInfoPropertiesEXT *)pNext), "VkPhysicalDevicePCIBusInfoPropertiesEXT", 1); + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:print_VkPhysicalDevice8BitStorageFeatures(((VkPhysicalDevice8BitStorageFeatures *)pNext), "VkPhysicalDevice8BitStorageFeatures", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:print_VkPhysicalDeviceVulkanMemoryModelFeatures(((VkPhysicalDeviceVulkanMemoryModelFeatures *)pNext), "VkPhysicalDeviceVulkanMemoryModelFeatures", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:print_VkPhysicalDeviceShaderAtomicInt64Features(((VkPhysicalDeviceShaderAtomicInt64Features *)pNext), "VkPhysicalDeviceShaderAtomicInt64Features", 1); + break; +#endif +#ifdef VK_EXT_shader_atomic_float + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:print_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(((VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)pNext), "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT", 1); + break; +#endif +#ifdef VK_EXT_vertex_attribute_divisor + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:print_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(((VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)pNext), "VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT", 1); + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:print_VkPhysicalDeviceDepthStencilResolveProperties(((VkPhysicalDeviceDepthStencilResolveProperties *)pNext), "VkPhysicalDeviceDepthStencilResolveProperties", 1); + break; + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:print_VkSubpassDescriptionDepthStencilResolve(((VkSubpassDescriptionDepthStencilResolve *)pNext), "VkSubpassDescriptionDepthStencilResolve", 1); + break; +#endif +#ifdef VK_EXT_astc_decode_mode + case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:print_VkImageViewASTCDecodeModeEXT(((VkImageViewASTCDecodeModeEXT *)pNext), "VkImageViewASTCDecodeModeEXT", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:print_VkPhysicalDeviceASTCDecodeFeaturesEXT(((VkPhysicalDeviceASTCDecodeFeaturesEXT *)pNext), "VkPhysicalDeviceASTCDecodeFeaturesEXT", 1); + break; +#endif +#ifdef VK_EXT_image_drm_format_modifier + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:print_VkDrmFormatModifierPropertiesListEXT(((VkDrmFormatModifierPropertiesListEXT *)pNext), "VkDrmFormatModifierPropertiesListEXT", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:print_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(((VkPhysicalDeviceImageDrmFormatModifierInfoEXT *)pNext), "VkPhysicalDeviceImageDrmFormatModifierInfoEXT", 1); + break; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:print_VkImageDrmFormatModifierListCreateInfoEXT(((VkImageDrmFormatModifierListCreateInfoEXT *)pNext), "VkImageDrmFormatModifierListCreateInfoEXT", 1); + break; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:print_VkImageDrmFormatModifierExplicitCreateInfoEXT(((VkImageDrmFormatModifierExplicitCreateInfoEXT *)pNext), "VkImageDrmFormatModifierExplicitCreateInfoEXT", 1); + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:print_VkImageStencilUsageCreateInfo(((VkImageStencilUsageCreateInfo *)pNext), "VkImageStencilUsageCreateInfo", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:print_VkPhysicalDeviceScalarBlockLayoutFeatures(((VkPhysicalDeviceScalarBlockLayoutFeatures *)pNext), "VkPhysicalDeviceScalarBlockLayoutFeatures", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:print_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(((VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pNext), "VkPhysicalDeviceUniformBufferStandardLayoutFeatures", 1); + break; +#endif +#ifdef VK_EXT_depth_clip_enable + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:print_VkPhysicalDeviceDepthClipEnableFeaturesEXT(((VkPhysicalDeviceDepthClipEnableFeaturesEXT *)pNext), "VkPhysicalDeviceDepthClipEnableFeaturesEXT", 1); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:print_VkPipelineRasterizationDepthClipStateCreateInfoEXT(((VkPipelineRasterizationDepthClipStateCreateInfoEXT *)pNext), "VkPipelineRasterizationDepthClipStateCreateInfoEXT", 1); + break; +#endif +#ifdef VK_EXT_memory_budget + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:print_VkPhysicalDeviceMemoryBudgetPropertiesEXT(((VkPhysicalDeviceMemoryBudgetPropertiesEXT *)pNext), "VkPhysicalDeviceMemoryBudgetPropertiesEXT", 1); + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:print_VkPhysicalDeviceBufferDeviceAddressFeatures(((VkPhysicalDeviceBufferDeviceAddressFeatures *)pNext), "VkPhysicalDeviceBufferDeviceAddressFeatures", 1); + break; + case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:print_VkBufferOpaqueCaptureAddressCreateInfo(((VkBufferOpaqueCaptureAddressCreateInfo *)pNext), "VkBufferOpaqueCaptureAddressCreateInfo", 1); + break; +#endif +#ifdef VK_EXT_filter_cubic + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:print_VkPhysicalDeviceImageViewImageFormatInfoEXT(((VkPhysicalDeviceImageViewImageFormatInfoEXT *)pNext), "VkPhysicalDeviceImageViewImageFormatInfoEXT", 1); + break; + case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:print_VkFilterCubicImageViewImageFormatPropertiesEXT(((VkFilterCubicImageViewImageFormatPropertiesEXT *)pNext), "VkFilterCubicImageViewImageFormatPropertiesEXT", 1); + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:print_VkPhysicalDeviceImagelessFramebufferFeatures(((VkPhysicalDeviceImagelessFramebufferFeatures *)pNext), "VkPhysicalDeviceImagelessFramebufferFeatures", 1); + break; + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:print_VkFramebufferAttachmentsCreateInfo(((VkFramebufferAttachmentsCreateInfo *)pNext), "VkFramebufferAttachmentsCreateInfo", 1); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:print_VkRenderPassAttachmentBeginInfo(((VkRenderPassAttachmentBeginInfo *)pNext), "VkRenderPassAttachmentBeginInfo", 1); + break; +#endif +#ifdef VK_EXT_texture_compression_astc_hdr + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:print_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(((VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *)pNext), "VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT", 1); + break; +#endif +#ifdef VK_EXT_ycbcr_image_arrays + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:print_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(((VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)pNext), "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT", 1); + break; +#endif +#ifdef VK_KHR_performance_query + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:print_VkPhysicalDevicePerformanceQueryFeaturesKHR(((VkPhysicalDevicePerformanceQueryFeaturesKHR *)pNext), "VkPhysicalDevicePerformanceQueryFeaturesKHR", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:print_VkPhysicalDevicePerformanceQueryPropertiesKHR(((VkPhysicalDevicePerformanceQueryPropertiesKHR *)pNext), "VkPhysicalDevicePerformanceQueryPropertiesKHR", 1); + break; + case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:print_VkQueryPoolPerformanceCreateInfoKHR(((VkQueryPoolPerformanceCreateInfoKHR *)pNext), "VkQueryPoolPerformanceCreateInfoKHR", 1); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:print_VkPerformanceQuerySubmitInfoKHR(((VkPerformanceQuerySubmitInfoKHR *)pNext), "VkPerformanceQuerySubmitInfoKHR", 1); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR:print_VkPerformanceQueryReservationInfoKHR(((VkPerformanceQueryReservationInfoKHR *)pNext), "VkPerformanceQueryReservationInfoKHR", 1); + break; +#endif +#ifdef VK_KHR_shader_clock + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:print_VkPhysicalDeviceShaderClockFeaturesKHR(((VkPhysicalDeviceShaderClockFeaturesKHR *)pNext), "VkPhysicalDeviceShaderClockFeaturesKHR", 1); + break; +#endif +#ifdef VK_EXT_index_type_uint8 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:print_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(((VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)pNext), "VkPhysicalDeviceIndexTypeUint8FeaturesEXT", 1); + break; +#endif +#ifdef VK_EXT_fragment_shader_interlock + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:print_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(((VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)pNext), "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT", 1); + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:print_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(((VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pNext), "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures", 1); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:print_VkAttachmentReferenceStencilLayout(((VkAttachmentReferenceStencilLayout *)pNext), "VkAttachmentReferenceStencilLayout", 1); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:print_VkAttachmentDescriptionStencilLayout(((VkAttachmentDescriptionStencilLayout *)pNext), "VkAttachmentDescriptionStencilLayout", 1); + break; +#endif +#ifdef VK_EXT_shader_demote_to_helper_invocation + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:print_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(((VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *)pNext), "VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT", 1); + break; +#endif +#ifdef VK_EXT_texel_buffer_alignment + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:print_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(((VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pNext), "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:print_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(((VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *)pNext), "VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT", 1); + break; +#endif +#ifdef VK_EXT_subgroup_size_control + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:print_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(((VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *)pNext), "VkPhysicalDeviceSubgroupSizeControlFeaturesEXT", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:print_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(((VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *)pNext), "VkPhysicalDeviceSubgroupSizeControlPropertiesEXT", 1); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:print_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(((VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *)pNext), "VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT", 1); + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:print_VkMemoryOpaqueCaptureAddressAllocateInfo(((VkMemoryOpaqueCaptureAddressAllocateInfo *)pNext), "VkMemoryOpaqueCaptureAddressAllocateInfo", 1); + break; +#endif +#ifdef VK_EXT_line_rasterization + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:print_VkPhysicalDeviceLineRasterizationFeaturesEXT(((VkPhysicalDeviceLineRasterizationFeaturesEXT *)pNext), "VkPhysicalDeviceLineRasterizationFeaturesEXT", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:print_VkPhysicalDeviceLineRasterizationPropertiesEXT(((VkPhysicalDeviceLineRasterizationPropertiesEXT *)pNext), "VkPhysicalDeviceLineRasterizationPropertiesEXT", 1); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:print_VkPipelineRasterizationLineStateCreateInfoEXT(((VkPipelineRasterizationLineStateCreateInfoEXT *)pNext), "VkPipelineRasterizationLineStateCreateInfoEXT", 1); + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:print_VkPhysicalDeviceVulkan11Features(((VkPhysicalDeviceVulkan11Features *)pNext), "VkPhysicalDeviceVulkan11Features", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:print_VkPhysicalDeviceVulkan11Properties(((VkPhysicalDeviceVulkan11Properties *)pNext), "VkPhysicalDeviceVulkan11Properties", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:print_VkPhysicalDeviceVulkan12Features(((VkPhysicalDeviceVulkan12Features *)pNext), "VkPhysicalDeviceVulkan12Features", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:print_VkPhysicalDeviceVulkan12Properties(((VkPhysicalDeviceVulkan12Properties *)pNext), "VkPhysicalDeviceVulkan12Properties", 1); + break; +#endif +#ifdef VKSC_VERSION_1_0 + case VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO:print_VkFaultCallbackInfo(((VkFaultCallbackInfo *)pNext), "VkFaultCallbackInfo", 1); + break; +#endif +#ifdef VK_EXT_custom_border_color + case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:print_VkSamplerCustomBorderColorCreateInfoEXT(((VkSamplerCustomBorderColorCreateInfoEXT *)pNext), "VkSamplerCustomBorderColorCreateInfoEXT", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:print_VkPhysicalDeviceCustomBorderColorPropertiesEXT(((VkPhysicalDeviceCustomBorderColorPropertiesEXT *)pNext), "VkPhysicalDeviceCustomBorderColorPropertiesEXT", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:print_VkPhysicalDeviceCustomBorderColorFeaturesEXT(((VkPhysicalDeviceCustomBorderColorFeaturesEXT *)pNext), "VkPhysicalDeviceCustomBorderColorFeaturesEXT", 1); + break; +#endif +#ifdef VK_EXT_extended_dynamic_state + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:print_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(((VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pNext), "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT", 1); + break; +#endif +#ifdef VK_EXT_extended_dynamic_state2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:print_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(((VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pNext), "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT", 1); + break; +#endif +#ifdef VKSC_VERSION_1_0 + case VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO:print_VkPipelineOfflineCreateInfo(((VkPipelineOfflineCreateInfo *)pNext), "VkPipelineOfflineCreateInfo", 1); + break; +#endif +#ifdef VK_EXT_robustness2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:print_VkPhysicalDeviceRobustness2FeaturesEXT(((VkPhysicalDeviceRobustness2FeaturesEXT *)pNext), "VkPhysicalDeviceRobustness2FeaturesEXT", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:print_VkPhysicalDeviceRobustness2PropertiesEXT(((VkPhysicalDeviceRobustness2PropertiesEXT *)pNext), "VkPhysicalDeviceRobustness2PropertiesEXT", 1); + break; +#endif +#ifdef VK_EXT_image_robustness + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:print_VkPhysicalDeviceImageRobustnessFeaturesEXT(((VkPhysicalDeviceImageRobustnessFeaturesEXT *)pNext), "VkPhysicalDeviceImageRobustnessFeaturesEXT", 1); + break; +#endif +#ifdef VK_EXT_4444_formats + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:print_VkPhysicalDevice4444FormatsFeaturesEXT(((VkPhysicalDevice4444FormatsFeaturesEXT *)pNext), "VkPhysicalDevice4444FormatsFeaturesEXT", 1); + break; +#endif +#ifdef VK_EXT_shader_image_atomic_int64 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:print_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(((VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)pNext), "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT", 1); + break; +#endif +#ifdef VK_KHR_fragment_shading_rate + case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:print_VkFragmentShadingRateAttachmentInfoKHR(((VkFragmentShadingRateAttachmentInfoKHR *)pNext), "VkFragmentShadingRateAttachmentInfoKHR", 1); + break; + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:print_VkPipelineFragmentShadingRateStateCreateInfoKHR(((VkPipelineFragmentShadingRateStateCreateInfoKHR *)pNext), "VkPipelineFragmentShadingRateStateCreateInfoKHR", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:print_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(((VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)pNext), "VkPhysicalDeviceFragmentShadingRateFeaturesKHR", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:print_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(((VkPhysicalDeviceFragmentShadingRatePropertiesKHR *)pNext), "VkPhysicalDeviceFragmentShadingRatePropertiesKHR", 1); + break; +#endif +#ifdef VK_KHR_shader_terminate_invocation + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR:print_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(((VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *)pNext), "VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR", 1); + break; +#endif +#ifdef VK_EXT_vertex_input_dynamic_state + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:print_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(((VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)pNext), "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT", 1); + break; +#endif +#ifdef VK_EXT_color_write_enable + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:print_VkPhysicalDeviceColorWriteEnableFeaturesEXT(((VkPhysicalDeviceColorWriteEnableFeaturesEXT *)pNext), "VkPhysicalDeviceColorWriteEnableFeaturesEXT", 1); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:print_VkPipelineColorWriteCreateInfoEXT(((VkPipelineColorWriteCreateInfoEXT *)pNext), "VkPipelineColorWriteCreateInfoEXT", 1); + break; +#endif +#ifdef VK_KHR_synchronization2 + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR:print_VkMemoryBarrier2KHR(((VkMemoryBarrier2KHR *)pNext), "VkMemoryBarrier2KHR", 1); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:print_VkQueueFamilyCheckpointProperties2NV(((VkQueueFamilyCheckpointProperties2NV *)pNext), "VkQueueFamilyCheckpointProperties2NV", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR:print_VkPhysicalDeviceSynchronization2FeaturesKHR(((VkPhysicalDeviceSynchronization2FeaturesKHR *)pNext), "VkPhysicalDeviceSynchronization2FeaturesKHR", 1); + break; +#endif +#ifdef VKSC_VERSION_1_0 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES:print_VkPhysicalDeviceVulkanSC10Properties(((VkPhysicalDeviceVulkanSC10Properties *)pNext), "VkPhysicalDeviceVulkanSC10Properties", 1); + break; + case VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO:print_VkDeviceObjectReservationCreateInfo(((VkDeviceObjectReservationCreateInfo *)pNext), "VkDeviceObjectReservationCreateInfo", 1); + break; + case VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO:print_VkCommandPoolMemoryReservationCreateInfo(((VkCommandPoolMemoryReservationCreateInfo *)pNext), "VkCommandPoolMemoryReservationCreateInfo", 1); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES:print_VkPhysicalDeviceVulkanSC10Features(((VkPhysicalDeviceVulkanSC10Features *)pNext), "VkPhysicalDeviceVulkanSC10Features", 1); + break; +#endif +#ifdef VK_EXT_ycbcr_2plane_444_formats + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:print_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(((VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pNext), "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT", 1); + break; +#endif +#ifdef VK_EXT_image_drm_format_modifier + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:print_VkDrmFormatModifierPropertiesList2EXT(((VkDrmFormatModifierPropertiesList2EXT *)pNext), "VkDrmFormatModifierPropertiesList2EXT", 1); + break; +#endif + default: assert(!"No structure type matching!"); + } + } + } + +void print_VkBool32(const VkBool32 * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : \"%s\"%s\n", str, (*obj == 0) ? ("VK_FALSE") : ("VK_TRUE"), commaNeeded ? "," : ""); +} + +void print_VkDeviceAddress(const VkDeviceAddress * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : \"%" PRIu64 "\"%s\n", str, *obj, commaNeeded ? "," : ""); +} + +void print_VkDeviceSize(const VkDeviceSize * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : \"%" PRIu64 "\"%s\n", str, *obj, commaNeeded ? "," : ""); +} + +void print_VkFlags(const VkFlags * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : \"%u\"%s\n", str, *obj, commaNeeded ? "," : ""); +} + +void print_VkSampleMask(const VkSampleMask * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : \"%u\"%s\n", str, *obj, commaNeeded ? "," : ""); +} + +void print_VkBuffer(const VkBuffer * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkImage(const VkImage * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkInstance(const VkInstance * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkPhysicalDevice(const VkPhysicalDevice * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkDevice(const VkDevice * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkQueue(const VkQueue * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkSemaphore(const VkSemaphore * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkCommandBuffer(const VkCommandBuffer * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkFence(const VkFence * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkDeviceMemory(const VkDeviceMemory * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkEvent(const VkEvent * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkQueryPool(const VkQueryPool * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkBufferView(const VkBufferView * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkImageView(const VkImageView * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkShaderModule(const VkShaderModule * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkPipelineCache(const VkPipelineCache * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkPipelineLayout(const VkPipelineLayout * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkPipeline(const VkPipeline * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkRenderPass(const VkRenderPass * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkDescriptorSetLayout(const VkDescriptorSetLayout * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkSampler(const VkSampler * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkDescriptorSet(const VkDescriptorSet * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkDescriptorPool(const VkDescriptorPool * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkFramebuffer(const VkFramebuffer * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +void print_VkCommandPool(const VkCommandPool * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +static const char* VkResult_map(int o) { +switch (o) { + case 0: return "VK_SUCCESS"; + case 1: return "VK_NOT_READY"; + case 2: return "VK_TIMEOUT"; + case 3: return "VK_EVENT_SET"; + case 4: return "VK_EVENT_RESET"; + case 5: return "VK_INCOMPLETE"; + case -1: return "VK_ERROR_OUT_OF_HOST_MEMORY"; + case -2: return "VK_ERROR_OUT_OF_DEVICE_MEMORY"; + case -3: return "VK_ERROR_INITIALIZATION_FAILED"; + case -4: return "VK_ERROR_DEVICE_LOST"; + case -5: return "VK_ERROR_MEMORY_MAP_FAILED"; + case -6: return "VK_ERROR_LAYER_NOT_PRESENT"; + case -7: return "VK_ERROR_EXTENSION_NOT_PRESENT"; + case -8: return "VK_ERROR_FEATURE_NOT_PRESENT"; + case -9: return "VK_ERROR_INCOMPATIBLE_DRIVER"; + case -10: return "VK_ERROR_TOO_MANY_OBJECTS"; + case -11: return "VK_ERROR_FORMAT_NOT_SUPPORTED"; + case -12: return "VK_ERROR_FRAGMENTED_POOL"; + case -13: return "VK_ERROR_UNKNOWN"; + case 1000069000: return "VK_ERROR_OUT_OF_POOL_MEMORY"; + case 1000072003: return "VK_ERROR_INVALID_EXTERNAL_HANDLE"; + case 1000161000: return "VK_ERROR_FRAGMENTATION"; + case 1000257000: return "VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS"; + case 1000011001: return "VK_ERROR_VALIDATION_FAILED"; + case 1000298000: return "VK_ERROR_INVALID_PIPELINE_CACHE_DATA"; + case 1000298001: return "VK_ERROR_NO_PIPELINE_MATCH"; + case 1000000000: return "VK_ERROR_SURFACE_LOST_KHR"; + case 1000000001: return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR"; + case 1000001003: return "VK_SUBOPTIMAL_KHR"; + case 1000001004: return "VK_ERROR_OUT_OF_DATE_KHR"; + case 1000003001: return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR"; + case 1000012000: return "VK_ERROR_INVALID_SHADER_NV"; + case 1000158000: return "VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT"; + case 1000174001: return "VK_ERROR_NOT_PERMITTED_EXT"; + case 1000255000: return "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT"; + case 1000268000: return "VK_THREAD_IDLE_KHR"; + case 1000268001: return "VK_THREAD_DONE_KHR"; + case 1000268002: return "VK_OPERATION_DEFERRED_KHR"; + case 1000268003: return "VK_OPERATION_NOT_DEFERRED_KHR"; + case 1000297000: return "VK_PIPELINE_COMPILE_REQUIRED_EXT"; + } + return NULL; +} +void print_VkResult(const VkResult* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkResult_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkStructureType_map(int o) { +switch (o) { + case 0: return "VK_STRUCTURE_TYPE_APPLICATION_INFO"; + case 1: return "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO"; + case 2: return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO"; + case 3: return "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO"; + case 4: return "VK_STRUCTURE_TYPE_SUBMIT_INFO"; + case 5: return "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO"; + case 6: return "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE"; + case 8: return "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO"; + case 9: return "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO"; + case 10: return "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO"; + case 11: return "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO"; + case 12: return "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO"; + case 13: return "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO"; + case 14: return "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO"; + case 15: return "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO"; + case 17: return "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO"; + case 18: return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO"; + case 19: return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO"; + case 20: return "VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO"; + case 21: return "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO"; + case 22: return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO"; + case 23: return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO"; + case 24: return "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO"; + case 25: return "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO"; + case 26: return "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO"; + case 27: return "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO"; + case 28: return "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO"; + case 29: return "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO"; + case 30: return "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO"; + case 31: return "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO"; + case 32: return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO"; + case 33: return "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO"; + case 34: return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO"; + case 35: return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET"; + case 36: return "VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET"; + case 37: return "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO"; + case 38: return "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO"; + case 39: return "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO"; + case 40: return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO"; + case 41: return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO"; + case 42: return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO"; + case 43: return "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO"; + case 44: return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER"; + case 45: return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER"; + case 46: return "VK_STRUCTURE_TYPE_MEMORY_BARRIER"; + case 47: return "VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO"; + case 48: return "VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO"; + case 1000094000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES"; + case 1000157000: return "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO"; + case 1000157001: return "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO"; + case 1000083000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES"; + case 1000127000: return "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS"; + case 1000127001: return "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO"; + case 1000060000: return "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO"; + case 1000060003: return "VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO"; + case 1000060004: return "VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO"; + case 1000060005: return "VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO"; + case 1000060013: return "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO"; + case 1000060014: return "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO"; + case 1000070000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES"; + case 1000070001: return "VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO"; + case 1000146000: return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2"; + case 1000146001: return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2"; + case 1000146003: return "VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2"; + case 1000059000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2"; + case 1000059001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2"; + case 1000059002: return "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2"; + case 1000059003: return "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2"; + case 1000059004: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2"; + case 1000059005: return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2"; + case 1000059006: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2"; + case 1000117000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES"; + case 1000117001: return "VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO"; + case 1000117002: return "VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO"; + case 1000117003: return "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO"; + case 1000053000: return "VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO"; + case 1000053001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES"; + case 1000053002: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES"; + case 1000120000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES"; + case 1000145000: return "VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO"; + case 1000145001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES"; + case 1000145002: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES"; + case 1000145003: return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2"; + case 1000156000: return "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO"; + case 1000156001: return "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO"; + case 1000156002: return "VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO"; + case 1000156003: return "VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO"; + case 1000156004: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES"; + case 1000156005: return "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES"; + case 1000071000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO"; + case 1000071001: return "VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES"; + case 1000071002: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO"; + case 1000071003: return "VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES"; + case 1000071004: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES"; + case 1000072000: return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO"; + case 1000072001: return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO"; + case 1000072002: return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO"; + case 1000112000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO"; + case 1000112001: return "VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES"; + case 1000113000: return "VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO"; + case 1000077000: return "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO"; + case 1000076000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO"; + case 1000076001: return "VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES"; + case 1000168000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES"; + case 1000168001: return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT"; + case 1000063000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES"; + case 49: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES"; + case 50: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES"; + case 51: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES"; + case 52: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES"; + case 1000147000: return "VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO"; + case 1000109000: return "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2"; + case 1000109001: return "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2"; + case 1000109002: return "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2"; + case 1000109003: return "VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2"; + case 1000109004: return "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2"; + case 1000109005: return "VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO"; + case 1000109006: return "VK_STRUCTURE_TYPE_SUBPASS_END_INFO"; + case 1000177000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES"; + case 1000196000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES"; + case 1000180000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES"; + case 1000082000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES"; + case 1000197000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES"; + case 1000161000: return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO"; + case 1000161001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES"; + case 1000161002: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES"; + case 1000161003: return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO"; + case 1000161004: return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT"; + case 1000199000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES"; + case 1000199001: return "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE"; + case 1000221000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES"; + case 1000246000: return "VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO"; + case 1000130000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES"; + case 1000130001: return "VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO"; + case 1000211000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES"; + case 1000108000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES"; + case 1000108001: return "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO"; + case 1000108002: return "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO"; + case 1000108003: return "VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO"; + case 1000253000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES"; + case 1000175000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES"; + case 1000241000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES"; + case 1000241001: return "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT"; + case 1000241002: return "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT"; + case 1000261000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES"; + case 1000207000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES"; + case 1000207001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES"; + case 1000207002: return "VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO"; + case 1000207003: return "VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO"; + case 1000207004: return "VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO"; + case 1000207005: return "VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO"; + case 1000257000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES"; + case 1000244001: return "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO"; + case 1000257002: return "VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO"; + case 1000257003: return "VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO"; + case 1000257004: return "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO"; + case 1000298000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES"; + case 1000298001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES"; + case 1000298002: return "VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO"; + case 1000298003: return "VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO"; + case 1000298004: return "VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_CONSUMPTION"; + case 1000298005: return "VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE"; + case 1000298007: return "VK_STRUCTURE_TYPE_FAULT_DATA"; + case 1000298008: return "VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO"; + case 1000298010: return "VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO"; + case 1000001000: return "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR"; + case 1000001001: return "VK_STRUCTURE_TYPE_PRESENT_INFO_KHR"; + case 1000060007: return "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR"; + case 1000060008: return "VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR"; + case 1000060009: return "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR"; + case 1000060010: return "VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR"; + case 1000060011: return "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR"; + case 1000060012: return "VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR"; + case 1000002000: return "VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR"; + case 1000002001: return "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR"; + case 1000003000: return "VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR"; + case 1000004000: return "VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR"; + case 1000005000: return "VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR"; + case 1000006000: return "VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR"; + case 1000008000: return "VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR"; + case 1000009000: return "VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR"; + case 1000010000: return "VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID"; + case 1000010001: return "VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID"; + case 1000010002: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID"; + case 1000011000: return "VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT"; + case 1000018000: return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD"; + case 1000022000: return "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT"; + case 1000022001: return "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT"; + case 1000022002: return "VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT"; + case 1000023000: return "VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR"; + case 1000023001: return "VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR"; + case 1000023002: return "VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR"; + case 1000023003: return "VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR"; + case 1000023004: return "VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR"; + case 1000023005: return "VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR"; + case 1000023006: return "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR"; + case 1000023007: return "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR"; + case 1000023008: return "VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR"; + case 1000023009: return "VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR"; + case 1000023010: return "VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR"; + case 1000023011: return "VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR"; + case 1000023012: return "VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR"; + case 1000023013: return "VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR"; + case 1000023014: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR"; + case 1000023015: return "VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR"; + case 1000024000: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR"; + case 1000026000: return "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV"; + case 1000026001: return "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV"; + case 1000026002: return "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV"; + case 1000028000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT"; + case 1000028001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT"; + case 1000028002: return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT"; + case 1000029000: return "VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX"; + case 1000029001: return "VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX"; + case 1000029002: return "VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX"; + case 1000030000: return "VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX"; + case 1000030001: return "VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX"; + case 1000038000: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT"; + case 1000038001: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT"; + case 1000038002: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT"; + case 1000038003: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT"; + case 1000038004: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT"; + case 1000038005: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT"; + case 1000038006: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT"; + case 1000038007: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT"; + case 1000038008: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT"; + case 1000038009: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT"; + case 1000038010: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT"; + case 1000039000: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT"; + case 1000039001: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT"; + case 1000039002: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT"; + case 1000039003: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT"; + case 1000039004: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT"; + case 1000039005: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT"; + case 1000039006: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_EXT"; + case 1000039007: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT"; + case 1000039008: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT"; + case 1000039009: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT"; + case 1000039010: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT"; + case 1000039011: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT"; + case 1000040000: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT"; + case 1000040001: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT"; + case 1000040002: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT"; + case 1000040003: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT"; + case 1000040004: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT"; + case 1000040005: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT"; + case 1000040006: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT"; + case 1000040007: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT"; + case 1000041000: return "VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD"; + case 1000044000: return "VK_STRUCTURE_TYPE_RENDERING_INFO_KHR"; + case 1000044001: return "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR"; + case 1000044002: return "VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR"; + case 1000044003: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR"; + case 1000044004: return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR"; + case 1000044006: return "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR"; + case 1000044007: return "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT"; + case 1000044008: return "VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD"; + case 1000044009: return "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX"; + case 1000049000: return "VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP"; + case 1000050000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV"; + case 1000056000: return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV"; + case 1000056001: return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV"; + case 1000057000: return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV"; + case 1000057001: return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV"; + case 1000058000: return "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV"; + case 1000061000: return "VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT"; + case 1000062000: return "VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN"; + case 1000066000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT"; + case 1000067000: return "VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT"; + case 1000067001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT"; + case 1000073000: return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR"; + case 1000073001: return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR"; + case 1000073002: return "VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR"; + case 1000073003: return "VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR"; + case 1000074000: return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR"; + case 1000074001: return "VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR"; + case 1000074002: return "VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR"; + case 1000075000: return "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR"; + case 1000078000: return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR"; + case 1000078001: return "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR"; + case 1000078002: return "VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR"; + case 1000078003: return "VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR"; + case 1000079000: return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR"; + case 1000079001: return "VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR"; + case 1000080000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR"; + case 1000081000: return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT"; + case 1000081001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT"; + case 1000081002: return "VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT"; + case 1000084000: return "VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR"; + case 1000087000: return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV"; + case 1000090000: return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT"; + case 1000091000: return "VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT"; + case 1000091001: return "VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT"; + case 1000091002: return "VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT"; + case 1000091003: return "VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT"; + case 1000092000: return "VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE"; + case 1000097000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX"; + case 1000098000: return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV"; + case 1000099000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT"; + case 1000099001: return "VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT"; + case 1000101000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT"; + case 1000101001: return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT"; + case 1000102000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT"; + case 1000102001: return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT"; + case 1000105000: return "VK_STRUCTURE_TYPE_HDR_METADATA_EXT"; + case 1000111000: return "VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR"; + case 1000114000: return "VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR"; + case 1000114001: return "VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR"; + case 1000114002: return "VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR"; + case 1000115000: return "VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR"; + case 1000115001: return "VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR"; + case 1000116000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR"; + case 1000116001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR"; + case 1000116002: return "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR"; + case 1000116003: return "VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR"; + case 1000116004: return "VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR"; + case 1000116005: return "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR"; + case 1000116006: return "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR"; + case 1000116007: return "VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR"; + case 1000119000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR"; + case 1000119001: return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR"; + case 1000119002: return "VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR"; + case 1000121000: return "VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR"; + case 1000121001: return "VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR"; + case 1000121002: return "VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR"; + case 1000121003: return "VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR"; + case 1000121004: return "VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR"; + case 1000122000: return "VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK"; + case 1000123000: return "VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK"; + case 1000128000: return "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT"; + case 1000128001: return "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT"; + case 1000128002: return "VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT"; + case 1000128003: return "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT"; + case 1000128004: return "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT"; + case 1000129000: return "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID"; + case 1000129001: return "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID"; + case 1000129002: return "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID"; + case 1000129003: return "VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID"; + case 1000129004: return "VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID"; + case 1000129005: return "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID"; + case 1000129006: return "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID"; + case 1000138000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT"; + case 1000138001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT"; + case 1000138002: return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT"; + case 1000138003: return "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT"; + case 1000143000: return "VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT"; + case 1000143001: return "VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT"; + case 1000143002: return "VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT"; + case 1000143003: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT"; + case 1000143004: return "VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT"; + case 1000148000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT"; + case 1000148001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT"; + case 1000148002: return "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT"; + case 1000149000: return "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV"; + case 1000150007: return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR"; + case 1000150000: return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR"; + case 1000150002: return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR"; + case 1000150003: return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR"; + case 1000150004: return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR"; + case 1000150005: return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR"; + case 1000150006: return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR"; + case 1000150009: return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR"; + case 1000150010: return "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR"; + case 1000150011: return "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR"; + case 1000150012: return "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR"; + case 1000150013: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR"; + case 1000150014: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR"; + case 1000150017: return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR"; + case 1000150020: return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR"; + case 1000347000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR"; + case 1000347001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR"; + case 1000150015: return "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR"; + case 1000150016: return "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR"; + case 1000150018: return "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR"; + case 1000348013: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR"; + case 1000152000: return "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV"; + case 1000154000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV"; + case 1000154001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV"; + case 1000158000: return "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT"; + case 1000158002: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT"; + case 1000158003: return "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT"; + case 1000158004: return "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT"; + case 1000158005: return "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT"; + case 1000158006: return "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT"; + case 1000160000: return "VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT"; + case 1000160001: return "VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT"; + case 1000163000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR"; + case 1000163001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR"; + case 1000164000: return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV"; + case 1000164001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV"; + case 1000164002: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV"; + case 1000164005: return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV"; + case 1000165000: return "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV"; + case 1000165001: return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV"; + case 1000165003: return "VK_STRUCTURE_TYPE_GEOMETRY_NV"; + case 1000165004: return "VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV"; + case 1000165005: return "VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV"; + case 1000165006: return "VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV"; + case 1000165007: return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV"; + case 1000165008: return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV"; + case 1000165009: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV"; + case 1000165011: return "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV"; + case 1000165012: return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV"; + case 1000166000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV"; + case 1000166001: return "VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV"; + case 1000170000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT"; + case 1000170001: return "VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT"; + case 1000174000: return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT"; + case 1000178000: return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT"; + case 1000178001: return "VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT"; + case 1000178002: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT"; + case 1000181000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR"; + case 1000183000: return "VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD"; + case 1000184000: return "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT"; + case 1000185000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD"; + case 1000187000: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT"; + case 1000187001: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT"; + case 1000187002: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT"; + case 1000187003: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT"; + case 1000187004: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT"; + case 1000187005: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT"; + case 1000187006: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT"; + case 1000189000: return "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD"; + case 1000190000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT"; + case 1000190001: return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT"; + case 1000190002: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT"; + case 1000191000: return "VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP"; + case 1000192000: return "VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT"; + case 1000201000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV"; + case 1000202000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV"; + case 1000202001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV"; + case 1000203000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV"; + case 1000204000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV"; + case 1000205000: return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV"; + case 1000205002: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV"; + case 1000206000: return "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV"; + case 1000206001: return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV"; + case 1000209000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL"; + case 1000210000: return "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL"; + case 1000210001: return "VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL"; + case 1000210002: return "VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL"; + case 1000210003: return "VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL"; + case 1000210004: return "VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL"; + case 1000210005: return "VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL"; + case 1000212000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT"; + case 1000213000: return "VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD"; + case 1000213001: return "VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD"; + case 1000214000: return "VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA"; + case 1000215000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR"; + case 1000217000: return "VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT"; + case 1000218000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT"; + case 1000218001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT"; + case 1000218002: return "VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT"; + case 1000225000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT"; + case 1000225001: return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT"; + case 1000225002: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT"; + case 1000226000: return "VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR"; + case 1000226001: return "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR"; + case 1000226002: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR"; + case 1000226003: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR"; + case 1000226004: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR"; + case 1000227000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD"; + case 1000229000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD"; + case 1000234000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT"; + case 1000237000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT"; + case 1000238000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT"; + case 1000238001: return "VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT"; + case 1000239000: return "VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR"; + case 1000240000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV"; + case 1000244000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT"; + case 1000244002: return "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT"; + case 1000245000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT"; + case 1000247000: return "VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT"; + case 1000248000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR"; + case 1000249000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV"; + case 1000249001: return "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV"; + case 1000249002: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV"; + case 1000250000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV"; + case 1000250001: return "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV"; + case 1000250002: return "VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV"; + case 1000251000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT"; + case 1000252000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT"; + case 1000254000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT"; + case 1000254001: return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT"; + case 1000254002: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT"; + case 1000255000: return "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT"; + case 1000255002: return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT"; + case 1000255001: return "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT"; + case 1000256000: return "VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT"; + case 1000259000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT"; + case 1000259001: return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT"; + case 1000259002: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT"; + case 1000260000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT"; + case 1000265000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT"; + case 1000267000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT"; + case 1000269000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR"; + case 1000269001: return "VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR"; + case 1000269002: return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR"; + case 1000269003: return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR"; + case 1000269004: return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR"; + case 1000269005: return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR"; + case 1000273000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT"; + case 1000276000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT"; + case 1000277000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV"; + case 1000277001: return "VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV"; + case 1000277002: return "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV"; + case 1000277003: return "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV"; + case 1000277004: return "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV"; + case 1000277005: return "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV"; + case 1000277006: return "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV"; + case 1000277007: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV"; + case 1000278000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV"; + case 1000278001: return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV"; + case 1000280000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR"; + case 1000280001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR"; + case 1000281000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT"; + case 1000281001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT"; + case 1000282000: return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM"; + case 1000282001: return "VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM"; + case 1000284000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT"; + case 1000284001: return "VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT"; + case 1000284002: return "VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT"; + case 1000286000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT"; + case 1000286001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT"; + case 1000287000: return "VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT"; + case 1000287001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT"; + case 1000287002: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT"; + case 1000290000: return "VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR"; + case 1000294000: return "VK_STRUCTURE_TYPE_PRESENT_ID_KHR"; + case 1000294001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR"; + case 1000295000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT"; + case 1000295001: return "VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT"; + case 1000295002: return "VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT"; + case 1000297000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT"; + case 1000299000: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR"; + case 1000299001: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR"; + case 1000299002: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR"; + case 1000300000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV"; + case 1000300001: return "VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV"; + case 1000308000: return "VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR"; + case 1000309000: return "VK_STRUCTURE_TYPE_RESERVED_QCOM"; + case 1000314000: return "VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR"; + case 1000314001: return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR"; + case 1000314002: return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR"; + case 1000314003: return "VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR"; + case 1000314004: return "VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR"; + case 1000314005: return "VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR"; + case 1000314006: return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR"; + case 1000314007: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR"; + case 1000314008: return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV"; + case 1000314009: return "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV"; + case 1000323000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR"; + case 1000325000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR"; + case 1000326000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV"; + case 1000326001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV"; + case 1000326002: return "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV"; + case 1000327000: return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV"; + case 1000327001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV"; + case 1000327002: return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV"; + case 1000330000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT"; + case 1000332000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT"; + case 1000332001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT"; + case 1000333000: return "VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM"; + case 1000335000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT"; + case 1000336000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR"; + case 1000337000: return "VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR"; + case 1000337001: return "VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR"; + case 1000337002: return "VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR"; + case 1000337003: return "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR"; + case 1000337004: return "VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR"; + case 1000337005: return "VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR"; + case 1000337006: return "VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR"; + case 1000337007: return "VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR"; + case 1000337008: return "VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR"; + case 1000337009: return "VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR"; + case 1000337010: return "VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR"; + case 1000340000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT"; + case 1000342000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM"; + case 1000344000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT"; + case 1000346000: return "VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT"; + case 1000351000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE"; + case 1000351002: return "VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE"; + case 1000352000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT"; + case 1000352001: return "VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT"; + case 1000352002: return "VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT"; + case 1000353000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT"; + case 1000355000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT"; + case 1000355001: return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT"; + case 1000356000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT"; + case 1000360000: return "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR"; + case 1000364000: return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA"; + case 1000364001: return "VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA"; + case 1000364002: return "VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA"; + case 1000365000: return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA"; + case 1000365001: return "VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA"; + case 1000366000: return "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA"; + case 1000366001: return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA"; + case 1000366002: return "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA"; + case 1000366003: return "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA"; + case 1000366004: return "VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA"; + case 1000366005: return "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA"; + case 1000366006: return "VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA"; + case 1000366007: return "VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA"; + case 1000366008: return "VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA"; + case 1000366009: return "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA"; + case 1000369000: return "VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI"; + case 1000369001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI"; + case 1000369002: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI"; + case 1000370000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI"; + case 1000371000: return "VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV"; + case 1000371001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV"; + case 1000377000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT"; + case 1000378000: return "VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX"; + case 1000381000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT"; + case 1000381001: return "VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT"; + case 1000388000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT"; + case 1000388001: return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT"; + case 1000391000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT"; + case 1000391001: return "VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT"; + case 1000392000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT"; + case 1000392001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT"; + case 1000411000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT"; + case 1000411001: return "VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT"; + case 1000412000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT"; + case 1000413000: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR"; + case 1000413001: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR"; + case 1000413002: return "VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR"; + case 1000413003: return "VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR"; + case 1000435000: return "VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT"; + } + return NULL; +} +void print_VkStructureType(const VkStructureType* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkStructureType_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkAccessFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_ACCESS_INDIRECT_COMMAND_READ_BIT"; + case (1 << 1): return "VK_ACCESS_INDEX_READ_BIT"; + case (1 << 2): return "VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT"; + case (1 << 3): return "VK_ACCESS_UNIFORM_READ_BIT"; + case (1 << 4): return "VK_ACCESS_INPUT_ATTACHMENT_READ_BIT"; + case (1 << 5): return "VK_ACCESS_SHADER_READ_BIT"; + case (1 << 6): return "VK_ACCESS_SHADER_WRITE_BIT"; + case (1 << 7): return "VK_ACCESS_COLOR_ATTACHMENT_READ_BIT"; + case (1 << 8): return "VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT"; + case (1 << 9): return "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT"; + case (1 << 10): return "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT"; + case (1 << 11): return "VK_ACCESS_TRANSFER_READ_BIT"; + case (1 << 12): return "VK_ACCESS_TRANSFER_WRITE_BIT"; + case (1 << 13): return "VK_ACCESS_HOST_READ_BIT"; + case (1 << 14): return "VK_ACCESS_HOST_WRITE_BIT"; + case (1 << 15): return "VK_ACCESS_MEMORY_READ_BIT"; + case (1 << 16): return "VK_ACCESS_MEMORY_WRITE_BIT"; + case (1 << 25): return "VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT"; + case (1 << 26): return "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT"; + case (1 << 27): return "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT"; + case (1 << 20): return "VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT"; + case (1 << 19): return "VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT"; + case (1 << 21): return "VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR"; + case (1 << 22): return "VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR"; + case (1 << 24): return "VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT"; + case (1 << 23): return "VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR"; + case (1 << 17): return "VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV"; + case (1 << 18): return "VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV"; + case 0: return "VK_ACCESS_NONE_KHR"; + } + return NULL; +} +void print_VkAccessFlagBits(const VkAccessFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkAccessFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkImageLayout_map(int o) { +switch (o) { + case 0: return "VK_IMAGE_LAYOUT_UNDEFINED"; + case 1: return "VK_IMAGE_LAYOUT_GENERAL"; + case 2: return "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL"; + case 3: return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL"; + case 4: return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL"; + case 5: return "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL"; + case 6: return "VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL"; + case 7: return "VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL"; + case 8: return "VK_IMAGE_LAYOUT_PREINITIALIZED"; + case 1000117000: return "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL"; + case 1000117001: return "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL"; + case 1000241000: return "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL"; + case 1000241001: return "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL"; + case 1000241002: return "VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL"; + case 1000241003: return "VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL"; + case 1000001002: return "VK_IMAGE_LAYOUT_PRESENT_SRC_KHR"; + case 1000024000: return "VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR"; + case 1000024001: return "VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR"; + case 1000024002: return "VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR"; + case 1000111000: return "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR"; + case 1000218000: return "VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"; + case 1000164003: return "VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR"; + case 1000299000: return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR"; + case 1000299001: return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR"; + case 1000299002: return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR"; + case 1000314000: return "VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR"; + case 1000314001: return "VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR"; + } + return NULL; +} +void print_VkImageLayout(const VkImageLayout* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkImageLayout_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkImageAspectFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_IMAGE_ASPECT_COLOR_BIT"; + case (1 << 1): return "VK_IMAGE_ASPECT_DEPTH_BIT"; + case (1 << 2): return "VK_IMAGE_ASPECT_STENCIL_BIT"; + case (1 << 3): return "VK_IMAGE_ASPECT_METADATA_BIT"; + case (1 << 4): return "VK_IMAGE_ASPECT_PLANE_0_BIT"; + case (1 << 5): return "VK_IMAGE_ASPECT_PLANE_1_BIT"; + case (1 << 6): return "VK_IMAGE_ASPECT_PLANE_2_BIT"; + case (1 << 7): return "VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT"; + case (1 << 8): return "VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT"; + case (1 << 9): return "VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT"; + case (1 << 10): return "VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT"; + case 0: return "VK_IMAGE_ASPECT_NONE_KHR"; + } + return NULL; +} +void print_VkImageAspectFlagBits(const VkImageAspectFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkImageAspectFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkObjectType_map(int o) { +switch (o) { + case 0: return "VK_OBJECT_TYPE_UNKNOWN"; + case 1: return "VK_OBJECT_TYPE_INSTANCE"; + case 2: return "VK_OBJECT_TYPE_PHYSICAL_DEVICE"; + case 3: return "VK_OBJECT_TYPE_DEVICE"; + case 4: return "VK_OBJECT_TYPE_QUEUE"; + case 5: return "VK_OBJECT_TYPE_SEMAPHORE"; + case 6: return "VK_OBJECT_TYPE_COMMAND_BUFFER"; + case 7: return "VK_OBJECT_TYPE_FENCE"; + case 8: return "VK_OBJECT_TYPE_DEVICE_MEMORY"; + case 9: return "VK_OBJECT_TYPE_BUFFER"; + case 10: return "VK_OBJECT_TYPE_IMAGE"; + case 11: return "VK_OBJECT_TYPE_EVENT"; + case 12: return "VK_OBJECT_TYPE_QUERY_POOL"; + case 13: return "VK_OBJECT_TYPE_BUFFER_VIEW"; + case 14: return "VK_OBJECT_TYPE_IMAGE_VIEW"; + case 16: return "VK_OBJECT_TYPE_PIPELINE_CACHE"; + case 17: return "VK_OBJECT_TYPE_PIPELINE_LAYOUT"; + case 18: return "VK_OBJECT_TYPE_RENDER_PASS"; + case 19: return "VK_OBJECT_TYPE_PIPELINE"; + case 20: return "VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT"; + case 21: return "VK_OBJECT_TYPE_SAMPLER"; + case 22: return "VK_OBJECT_TYPE_DESCRIPTOR_POOL"; + case 23: return "VK_OBJECT_TYPE_DESCRIPTOR_SET"; + case 24: return "VK_OBJECT_TYPE_FRAMEBUFFER"; + case 25: return "VK_OBJECT_TYPE_COMMAND_POOL"; + case 1000156000: return "VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION"; + case 1000000000: return "VK_OBJECT_TYPE_SURFACE_KHR"; + case 1000001000: return "VK_OBJECT_TYPE_SWAPCHAIN_KHR"; + case 1000002000: return "VK_OBJECT_TYPE_DISPLAY_KHR"; + case 1000002001: return "VK_OBJECT_TYPE_DISPLAY_MODE_KHR"; + case 1000011000: return "VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT"; + case 1000023000: return "VK_OBJECT_TYPE_VIDEO_SESSION_KHR"; + case 1000023001: return "VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR"; + case 1000029000: return "VK_OBJECT_TYPE_CU_MODULE_NVX"; + case 1000029001: return "VK_OBJECT_TYPE_CU_FUNCTION_NVX"; + case 1000128000: return "VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT"; + case 1000150000: return "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR"; + case 1000160000: return "VK_OBJECT_TYPE_VALIDATION_CACHE_EXT"; + case 1000165000: return "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV"; + case 1000210000: return "VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL"; + case 1000268000: return "VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR"; + case 1000277000: return "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV"; + case 1000295000: return "VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT"; + case 1000366000: return "VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA"; + } + return NULL; +} +void print_VkObjectType(const VkObjectType* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkObjectType_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkPipelineCacheHeaderVersion_map(int o) { +switch (o) { + case 1: return "VK_PIPELINE_CACHE_HEADER_VERSION_ONE"; + case 1000298001: return "VK_PIPELINE_CACHE_HEADER_VERSION_SAFETY_CRITICAL_ONE"; + } + return NULL; +} +void print_VkPipelineCacheHeaderVersion(const VkPipelineCacheHeaderVersion* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkPipelineCacheHeaderVersion_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkVendorId_map(int o) { +switch (o) { + case 0x10001: return "VK_VENDOR_ID_VIV"; + case 0x10002: return "VK_VENDOR_ID_VSI"; + case 0x10003: return "VK_VENDOR_ID_KAZAN"; + case 0x10004: return "VK_VENDOR_ID_CODEPLAY"; + case 0x10005: return "VK_VENDOR_ID_MESA"; + case 0x10006: return "VK_VENDOR_ID_POCL"; + } + return NULL; +} +void print_VkVendorId(const VkVendorId* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkVendorId_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkSystemAllocationScope_map(int o) { +switch (o) { + case 0: return "VK_SYSTEM_ALLOCATION_SCOPE_COMMAND"; + case 1: return "VK_SYSTEM_ALLOCATION_SCOPE_OBJECT"; + case 2: return "VK_SYSTEM_ALLOCATION_SCOPE_CACHE"; + case 3: return "VK_SYSTEM_ALLOCATION_SCOPE_DEVICE"; + case 4: return "VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE"; + } + return NULL; +} +void print_VkSystemAllocationScope(const VkSystemAllocationScope* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkSystemAllocationScope_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkInternalAllocationType_map(int o) { +switch (o) { + case 0: return "VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE"; + } + return NULL; +} +void print_VkInternalAllocationType(const VkInternalAllocationType* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkInternalAllocationType_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkFormat_map(int o) { +switch (o) { + case 0: return "VK_FORMAT_UNDEFINED"; + case 1: return "VK_FORMAT_R4G4_UNORM_PACK8"; + case 2: return "VK_FORMAT_R4G4B4A4_UNORM_PACK16"; + case 3: return "VK_FORMAT_B4G4R4A4_UNORM_PACK16"; + case 4: return "VK_FORMAT_R5G6B5_UNORM_PACK16"; + case 5: return "VK_FORMAT_B5G6R5_UNORM_PACK16"; + case 6: return "VK_FORMAT_R5G5B5A1_UNORM_PACK16"; + case 7: return "VK_FORMAT_B5G5R5A1_UNORM_PACK16"; + case 8: return "VK_FORMAT_A1R5G5B5_UNORM_PACK16"; + case 9: return "VK_FORMAT_R8_UNORM"; + case 10: return "VK_FORMAT_R8_SNORM"; + case 11: return "VK_FORMAT_R8_USCALED"; + case 12: return "VK_FORMAT_R8_SSCALED"; + case 13: return "VK_FORMAT_R8_UINT"; + case 14: return "VK_FORMAT_R8_SINT"; + case 15: return "VK_FORMAT_R8_SRGB"; + case 16: return "VK_FORMAT_R8G8_UNORM"; + case 17: return "VK_FORMAT_R8G8_SNORM"; + case 18: return "VK_FORMAT_R8G8_USCALED"; + case 19: return "VK_FORMAT_R8G8_SSCALED"; + case 20: return "VK_FORMAT_R8G8_UINT"; + case 21: return "VK_FORMAT_R8G8_SINT"; + case 22: return "VK_FORMAT_R8G8_SRGB"; + case 23: return "VK_FORMAT_R8G8B8_UNORM"; + case 24: return "VK_FORMAT_R8G8B8_SNORM"; + case 25: return "VK_FORMAT_R8G8B8_USCALED"; + case 26: return "VK_FORMAT_R8G8B8_SSCALED"; + case 27: return "VK_FORMAT_R8G8B8_UINT"; + case 28: return "VK_FORMAT_R8G8B8_SINT"; + case 29: return "VK_FORMAT_R8G8B8_SRGB"; + case 30: return "VK_FORMAT_B8G8R8_UNORM"; + case 31: return "VK_FORMAT_B8G8R8_SNORM"; + case 32: return "VK_FORMAT_B8G8R8_USCALED"; + case 33: return "VK_FORMAT_B8G8R8_SSCALED"; + case 34: return "VK_FORMAT_B8G8R8_UINT"; + case 35: return "VK_FORMAT_B8G8R8_SINT"; + case 36: return "VK_FORMAT_B8G8R8_SRGB"; + case 37: return "VK_FORMAT_R8G8B8A8_UNORM"; + case 38: return "VK_FORMAT_R8G8B8A8_SNORM"; + case 39: return "VK_FORMAT_R8G8B8A8_USCALED"; + case 40: return "VK_FORMAT_R8G8B8A8_SSCALED"; + case 41: return "VK_FORMAT_R8G8B8A8_UINT"; + case 42: return "VK_FORMAT_R8G8B8A8_SINT"; + case 43: return "VK_FORMAT_R8G8B8A8_SRGB"; + case 44: return "VK_FORMAT_B8G8R8A8_UNORM"; + case 45: return "VK_FORMAT_B8G8R8A8_SNORM"; + case 46: return "VK_FORMAT_B8G8R8A8_USCALED"; + case 47: return "VK_FORMAT_B8G8R8A8_SSCALED"; + case 48: return "VK_FORMAT_B8G8R8A8_UINT"; + case 49: return "VK_FORMAT_B8G8R8A8_SINT"; + case 50: return "VK_FORMAT_B8G8R8A8_SRGB"; + case 51: return "VK_FORMAT_A8B8G8R8_UNORM_PACK32"; + case 52: return "VK_FORMAT_A8B8G8R8_SNORM_PACK32"; + case 53: return "VK_FORMAT_A8B8G8R8_USCALED_PACK32"; + case 54: return "VK_FORMAT_A8B8G8R8_SSCALED_PACK32"; + case 55: return "VK_FORMAT_A8B8G8R8_UINT_PACK32"; + case 56: return "VK_FORMAT_A8B8G8R8_SINT_PACK32"; + case 57: return "VK_FORMAT_A8B8G8R8_SRGB_PACK32"; + case 58: return "VK_FORMAT_A2R10G10B10_UNORM_PACK32"; + case 59: return "VK_FORMAT_A2R10G10B10_SNORM_PACK32"; + case 60: return "VK_FORMAT_A2R10G10B10_USCALED_PACK32"; + case 61: return "VK_FORMAT_A2R10G10B10_SSCALED_PACK32"; + case 62: return "VK_FORMAT_A2R10G10B10_UINT_PACK32"; + case 63: return "VK_FORMAT_A2R10G10B10_SINT_PACK32"; + case 64: return "VK_FORMAT_A2B10G10R10_UNORM_PACK32"; + case 65: return "VK_FORMAT_A2B10G10R10_SNORM_PACK32"; + case 66: return "VK_FORMAT_A2B10G10R10_USCALED_PACK32"; + case 67: return "VK_FORMAT_A2B10G10R10_SSCALED_PACK32"; + case 68: return "VK_FORMAT_A2B10G10R10_UINT_PACK32"; + case 69: return "VK_FORMAT_A2B10G10R10_SINT_PACK32"; + case 70: return "VK_FORMAT_R16_UNORM"; + case 71: return "VK_FORMAT_R16_SNORM"; + case 72: return "VK_FORMAT_R16_USCALED"; + case 73: return "VK_FORMAT_R16_SSCALED"; + case 74: return "VK_FORMAT_R16_UINT"; + case 75: return "VK_FORMAT_R16_SINT"; + case 76: return "VK_FORMAT_R16_SFLOAT"; + case 77: return "VK_FORMAT_R16G16_UNORM"; + case 78: return "VK_FORMAT_R16G16_SNORM"; + case 79: return "VK_FORMAT_R16G16_USCALED"; + case 80: return "VK_FORMAT_R16G16_SSCALED"; + case 81: return "VK_FORMAT_R16G16_UINT"; + case 82: return "VK_FORMAT_R16G16_SINT"; + case 83: return "VK_FORMAT_R16G16_SFLOAT"; + case 84: return "VK_FORMAT_R16G16B16_UNORM"; + case 85: return "VK_FORMAT_R16G16B16_SNORM"; + case 86: return "VK_FORMAT_R16G16B16_USCALED"; + case 87: return "VK_FORMAT_R16G16B16_SSCALED"; + case 88: return "VK_FORMAT_R16G16B16_UINT"; + case 89: return "VK_FORMAT_R16G16B16_SINT"; + case 90: return "VK_FORMAT_R16G16B16_SFLOAT"; + case 91: return "VK_FORMAT_R16G16B16A16_UNORM"; + case 92: return "VK_FORMAT_R16G16B16A16_SNORM"; + case 93: return "VK_FORMAT_R16G16B16A16_USCALED"; + case 94: return "VK_FORMAT_R16G16B16A16_SSCALED"; + case 95: return "VK_FORMAT_R16G16B16A16_UINT"; + case 96: return "VK_FORMAT_R16G16B16A16_SINT"; + case 97: return "VK_FORMAT_R16G16B16A16_SFLOAT"; + case 98: return "VK_FORMAT_R32_UINT"; + case 99: return "VK_FORMAT_R32_SINT"; + case 100: return "VK_FORMAT_R32_SFLOAT"; + case 101: return "VK_FORMAT_R32G32_UINT"; + case 102: return "VK_FORMAT_R32G32_SINT"; + case 103: return "VK_FORMAT_R32G32_SFLOAT"; + case 104: return "VK_FORMAT_R32G32B32_UINT"; + case 105: return "VK_FORMAT_R32G32B32_SINT"; + case 106: return "VK_FORMAT_R32G32B32_SFLOAT"; + case 107: return "VK_FORMAT_R32G32B32A32_UINT"; + case 108: return "VK_FORMAT_R32G32B32A32_SINT"; + case 109: return "VK_FORMAT_R32G32B32A32_SFLOAT"; + case 110: return "VK_FORMAT_R64_UINT"; + case 111: return "VK_FORMAT_R64_SINT"; + case 112: return "VK_FORMAT_R64_SFLOAT"; + case 113: return "VK_FORMAT_R64G64_UINT"; + case 114: return "VK_FORMAT_R64G64_SINT"; + case 115: return "VK_FORMAT_R64G64_SFLOAT"; + case 116: return "VK_FORMAT_R64G64B64_UINT"; + case 117: return "VK_FORMAT_R64G64B64_SINT"; + case 118: return "VK_FORMAT_R64G64B64_SFLOAT"; + case 119: return "VK_FORMAT_R64G64B64A64_UINT"; + case 120: return "VK_FORMAT_R64G64B64A64_SINT"; + case 121: return "VK_FORMAT_R64G64B64A64_SFLOAT"; + case 122: return "VK_FORMAT_B10G11R11_UFLOAT_PACK32"; + case 123: return "VK_FORMAT_E5B9G9R9_UFLOAT_PACK32"; + case 124: return "VK_FORMAT_D16_UNORM"; + case 125: return "VK_FORMAT_X8_D24_UNORM_PACK32"; + case 126: return "VK_FORMAT_D32_SFLOAT"; + case 127: return "VK_FORMAT_S8_UINT"; + case 128: return "VK_FORMAT_D16_UNORM_S8_UINT"; + case 129: return "VK_FORMAT_D24_UNORM_S8_UINT"; + case 130: return "VK_FORMAT_D32_SFLOAT_S8_UINT"; + case 131: return "VK_FORMAT_BC1_RGB_UNORM_BLOCK"; + case 132: return "VK_FORMAT_BC1_RGB_SRGB_BLOCK"; + case 133: return "VK_FORMAT_BC1_RGBA_UNORM_BLOCK"; + case 134: return "VK_FORMAT_BC1_RGBA_SRGB_BLOCK"; + case 135: return "VK_FORMAT_BC2_UNORM_BLOCK"; + case 136: return "VK_FORMAT_BC2_SRGB_BLOCK"; + case 137: return "VK_FORMAT_BC3_UNORM_BLOCK"; + case 138: return "VK_FORMAT_BC3_SRGB_BLOCK"; + case 139: return "VK_FORMAT_BC4_UNORM_BLOCK"; + case 140: return "VK_FORMAT_BC4_SNORM_BLOCK"; + case 141: return "VK_FORMAT_BC5_UNORM_BLOCK"; + case 142: return "VK_FORMAT_BC5_SNORM_BLOCK"; + case 143: return "VK_FORMAT_BC6H_UFLOAT_BLOCK"; + case 144: return "VK_FORMAT_BC6H_SFLOAT_BLOCK"; + case 145: return "VK_FORMAT_BC7_UNORM_BLOCK"; + case 146: return "VK_FORMAT_BC7_SRGB_BLOCK"; + case 147: return "VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK"; + case 148: return "VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK"; + case 149: return "VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK"; + case 150: return "VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK"; + case 151: return "VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK"; + case 152: return "VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK"; + case 153: return "VK_FORMAT_EAC_R11_UNORM_BLOCK"; + case 154: return "VK_FORMAT_EAC_R11_SNORM_BLOCK"; + case 155: return "VK_FORMAT_EAC_R11G11_UNORM_BLOCK"; + case 156: return "VK_FORMAT_EAC_R11G11_SNORM_BLOCK"; + case 157: return "VK_FORMAT_ASTC_4x4_UNORM_BLOCK"; + case 158: return "VK_FORMAT_ASTC_4x4_SRGB_BLOCK"; + case 159: return "VK_FORMAT_ASTC_5x4_UNORM_BLOCK"; + case 160: return "VK_FORMAT_ASTC_5x4_SRGB_BLOCK"; + case 161: return "VK_FORMAT_ASTC_5x5_UNORM_BLOCK"; + case 162: return "VK_FORMAT_ASTC_5x5_SRGB_BLOCK"; + case 163: return "VK_FORMAT_ASTC_6x5_UNORM_BLOCK"; + case 164: return "VK_FORMAT_ASTC_6x5_SRGB_BLOCK"; + case 165: return "VK_FORMAT_ASTC_6x6_UNORM_BLOCK"; + case 166: return "VK_FORMAT_ASTC_6x6_SRGB_BLOCK"; + case 167: return "VK_FORMAT_ASTC_8x5_UNORM_BLOCK"; + case 168: return "VK_FORMAT_ASTC_8x5_SRGB_BLOCK"; + case 169: return "VK_FORMAT_ASTC_8x6_UNORM_BLOCK"; + case 170: return "VK_FORMAT_ASTC_8x6_SRGB_BLOCK"; + case 171: return "VK_FORMAT_ASTC_8x8_UNORM_BLOCK"; + case 172: return "VK_FORMAT_ASTC_8x8_SRGB_BLOCK"; + case 173: return "VK_FORMAT_ASTC_10x5_UNORM_BLOCK"; + case 174: return "VK_FORMAT_ASTC_10x5_SRGB_BLOCK"; + case 175: return "VK_FORMAT_ASTC_10x6_UNORM_BLOCK"; + case 176: return "VK_FORMAT_ASTC_10x6_SRGB_BLOCK"; + case 177: return "VK_FORMAT_ASTC_10x8_UNORM_BLOCK"; + case 178: return "VK_FORMAT_ASTC_10x8_SRGB_BLOCK"; + case 179: return "VK_FORMAT_ASTC_10x10_UNORM_BLOCK"; + case 180: return "VK_FORMAT_ASTC_10x10_SRGB_BLOCK"; + case 181: return "VK_FORMAT_ASTC_12x10_UNORM_BLOCK"; + case 182: return "VK_FORMAT_ASTC_12x10_SRGB_BLOCK"; + case 183: return "VK_FORMAT_ASTC_12x12_UNORM_BLOCK"; + case 184: return "VK_FORMAT_ASTC_12x12_SRGB_BLOCK"; + case 1000156000: return "VK_FORMAT_G8B8G8R8_422_UNORM"; + case 1000156001: return "VK_FORMAT_B8G8R8G8_422_UNORM"; + case 1000156002: return "VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM"; + case 1000156003: return "VK_FORMAT_G8_B8R8_2PLANE_420_UNORM"; + case 1000156004: return "VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM"; + case 1000156005: return "VK_FORMAT_G8_B8R8_2PLANE_422_UNORM"; + case 1000156006: return "VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM"; + case 1000156007: return "VK_FORMAT_R10X6_UNORM_PACK16"; + case 1000156008: return "VK_FORMAT_R10X6G10X6_UNORM_2PACK16"; + case 1000156009: return "VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16"; + case 1000156010: return "VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16"; + case 1000156011: return "VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16"; + case 1000156012: return "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16"; + case 1000156013: return "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16"; + case 1000156014: return "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16"; + case 1000156015: return "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16"; + case 1000156016: return "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16"; + case 1000156017: return "VK_FORMAT_R12X4_UNORM_PACK16"; + case 1000156018: return "VK_FORMAT_R12X4G12X4_UNORM_2PACK16"; + case 1000156019: return "VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16"; + case 1000156020: return "VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16"; + case 1000156021: return "VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16"; + case 1000156022: return "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16"; + case 1000156023: return "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16"; + case 1000156024: return "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16"; + case 1000156025: return "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16"; + case 1000156026: return "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16"; + case 1000156027: return "VK_FORMAT_G16B16G16R16_422_UNORM"; + case 1000156028: return "VK_FORMAT_B16G16R16G16_422_UNORM"; + case 1000156029: return "VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM"; + case 1000156030: return "VK_FORMAT_G16_B16R16_2PLANE_420_UNORM"; + case 1000156031: return "VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM"; + case 1000156032: return "VK_FORMAT_G16_B16R16_2PLANE_422_UNORM"; + case 1000156033: return "VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM"; + case 1000054000: return "VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG"; + case 1000054001: return "VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG"; + case 1000054002: return "VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG"; + case 1000054003: return "VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG"; + case 1000054004: return "VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG"; + case 1000054005: return "VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG"; + case 1000054006: return "VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG"; + case 1000054007: return "VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG"; + case 1000066000: return "VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT"; + case 1000066001: return "VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT"; + case 1000066002: return "VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT"; + case 1000066003: return "VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT"; + case 1000066004: return "VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT"; + case 1000066005: return "VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT"; + case 1000066006: return "VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT"; + case 1000066007: return "VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT"; + case 1000066008: return "VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT"; + case 1000066009: return "VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT"; + case 1000066010: return "VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT"; + case 1000066011: return "VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT"; + case 1000066012: return "VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT"; + case 1000066013: return "VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT"; + case 1000288000: return "VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT"; + case 1000288001: return "VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT"; + case 1000288002: return "VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT"; + case 1000288003: return "VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT"; + case 1000288004: return "VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT"; + case 1000288005: return "VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT"; + case 1000288006: return "VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT"; + case 1000288007: return "VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT"; + case 1000288008: return "VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT"; + case 1000288009: return "VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT"; + case 1000288010: return "VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT"; + case 1000288011: return "VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT"; + case 1000288012: return "VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT"; + case 1000288013: return "VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT"; + case 1000288014: return "VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT"; + case 1000288015: return "VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT"; + case 1000288016: return "VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT"; + case 1000288017: return "VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT"; + case 1000288018: return "VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT"; + case 1000288019: return "VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT"; + case 1000288020: return "VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT"; + case 1000288021: return "VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT"; + case 1000288022: return "VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT"; + case 1000288023: return "VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT"; + case 1000288024: return "VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT"; + case 1000288025: return "VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT"; + case 1000288026: return "VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT"; + case 1000288027: return "VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT"; + case 1000288028: return "VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT"; + case 1000288029: return "VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT"; + case 1000330000: return "VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT"; + case 1000330001: return "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT"; + case 1000330002: return "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT"; + case 1000330003: return "VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT"; + case 1000340000: return "VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT"; + case 1000340001: return "VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT"; + } + return NULL; +} +void print_VkFormat(const VkFormat* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkFormat_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkFormatFeatureFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT"; + case (1 << 1): return "VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT"; + case (1 << 2): return "VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT"; + case (1 << 3): return "VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT"; + case (1 << 4): return "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT"; + case (1 << 5): return "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"; + case (1 << 6): return "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT"; + case (1 << 7): return "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT"; + case (1 << 8): return "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT"; + case (1 << 9): return "VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT"; + case (1 << 10): return "VK_FORMAT_FEATURE_BLIT_SRC_BIT"; + case (1 << 11): return "VK_FORMAT_FEATURE_BLIT_DST_BIT"; + case (1 << 12): return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT"; + case (1 << 14): return "VK_FORMAT_FEATURE_TRANSFER_SRC_BIT"; + case (1 << 15): return "VK_FORMAT_FEATURE_TRANSFER_DST_BIT"; + case (1 << 17): return "VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT"; + case (1 << 18): return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT"; + case (1 << 19): return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT"; + case (1 << 20): return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT"; + case (1 << 21): return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT"; + case (1 << 22): return "VK_FORMAT_FEATURE_DISJOINT_BIT"; + case (1 << 23): return "VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT"; + case (1 << 16): return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT"; + case (1 << 13): return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG"; + case (1 << 25): return "VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR"; + case (1 << 26): return "VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR"; + case (1 << 29): return "VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR"; + case (1 << 24): return "VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT"; + case (1 << 30): return "VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; + case (1 << 27): return "VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR"; + case (1 << 28): return "VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR"; + } + return NULL; +} +void print_VkFormatFeatureFlagBits(const VkFormatFeatureFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkFormatFeatureFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkImageCreateFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_IMAGE_CREATE_SPARSE_BINDING_BIT"; + case (1 << 1): return "VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT"; + case (1 << 2): return "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT"; + case (1 << 3): return "VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT"; + case (1 << 4): return "VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT"; + case (1 << 10): return "VK_IMAGE_CREATE_ALIAS_BIT"; + case (1 << 6): return "VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT"; + case (1 << 5): return "VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT"; + case (1 << 7): return "VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT"; + case (1 << 8): return "VK_IMAGE_CREATE_EXTENDED_USAGE_BIT"; + case (1 << 11): return "VK_IMAGE_CREATE_PROTECTED_BIT"; + case (1 << 9): return "VK_IMAGE_CREATE_DISJOINT_BIT"; + case (1 << 13): return "VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV"; + case (1 << 12): return "VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT"; + case (1 << 14): return "VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT"; + case (1 << 16): return "VK_IMAGE_CREATE_RESERVED_16_BIT_AMD"; + case (1 << 17): return "VK_IMAGE_CREATE_RESERVED_394_BIT_EXT"; + case (1 << 15): return "VK_IMAGE_CREATE_RESERVED_426_BIT_QCOM"; + } + return NULL; +} +void print_VkImageCreateFlagBits(const VkImageCreateFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkImageCreateFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkSampleCountFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_SAMPLE_COUNT_1_BIT"; + case (1 << 1): return "VK_SAMPLE_COUNT_2_BIT"; + case (1 << 2): return "VK_SAMPLE_COUNT_4_BIT"; + case (1 << 3): return "VK_SAMPLE_COUNT_8_BIT"; + case (1 << 4): return "VK_SAMPLE_COUNT_16_BIT"; + case (1 << 5): return "VK_SAMPLE_COUNT_32_BIT"; + case (1 << 6): return "VK_SAMPLE_COUNT_64_BIT"; + } + return NULL; +} +void print_VkSampleCountFlagBits(const VkSampleCountFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkSampleCountFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkImageTiling_map(int o) { +switch (o) { + case 0: return "VK_IMAGE_TILING_OPTIMAL"; + case 1: return "VK_IMAGE_TILING_LINEAR"; + case 1000158000: return "VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT"; + } + return NULL; +} +void print_VkImageTiling(const VkImageTiling* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkImageTiling_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkImageType_map(int o) { +switch (o) { + case 0: return "VK_IMAGE_TYPE_1D"; + case 1: return "VK_IMAGE_TYPE_2D"; + case 2: return "VK_IMAGE_TYPE_3D"; + } + return NULL; +} +void print_VkImageType(const VkImageType* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkImageType_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkImageUsageFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_IMAGE_USAGE_TRANSFER_SRC_BIT"; + case (1 << 1): return "VK_IMAGE_USAGE_TRANSFER_DST_BIT"; + case (1 << 2): return "VK_IMAGE_USAGE_SAMPLED_BIT"; + case (1 << 3): return "VK_IMAGE_USAGE_STORAGE_BIT"; + case (1 << 4): return "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT"; + case (1 << 5): return "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT"; + case (1 << 6): return "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT"; + case (1 << 7): return "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT"; + case (1 << 10): return "VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR"; + case (1 << 11): return "VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR"; + case (1 << 12): return "VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR"; + case (1 << 16): return "VK_IMAGE_USAGE_RESERVED_16_BIT_QCOM"; + case (1 << 17): return "VK_IMAGE_USAGE_RESERVED_17_BIT_QCOM"; + case (1 << 9): return "VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT"; + case (1 << 8): return "VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; + case (1 << 13): return "VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR"; + case (1 << 14): return "VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR"; + case (1 << 15): return "VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR"; + case (1 << 19): return "VK_IMAGE_USAGE_RESERVED_19_BIT_EXT"; + case (1 << 18): return "VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI"; + } + return NULL; +} +void print_VkImageUsageFlagBits(const VkImageUsageFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkImageUsageFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkMemoryHeapFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_MEMORY_HEAP_DEVICE_LOCAL_BIT"; + case (1 << 1): return "VK_MEMORY_HEAP_MULTI_INSTANCE_BIT"; + case (1 << 2): return "VK_MEMORY_HEAP_SEU_SAFE_BIT"; + } + return NULL; +} +void print_VkMemoryHeapFlagBits(const VkMemoryHeapFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkMemoryHeapFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkMemoryPropertyFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT"; + case (1 << 1): return "VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT"; + case (1 << 2): return "VK_MEMORY_PROPERTY_HOST_COHERENT_BIT"; + case (1 << 3): return "VK_MEMORY_PROPERTY_HOST_CACHED_BIT"; + case (1 << 4): return "VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT"; + case (1 << 5): return "VK_MEMORY_PROPERTY_PROTECTED_BIT"; + case (1 << 6): return "VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD"; + case (1 << 7): return "VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD"; + case (1 << 8): return "VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV"; + } + return NULL; +} +void print_VkMemoryPropertyFlagBits(const VkMemoryPropertyFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkMemoryPropertyFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkPhysicalDeviceType_map(int o) { +switch (o) { + case 0: return "VK_PHYSICAL_DEVICE_TYPE_OTHER"; + case 1: return "VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU"; + case 2: return "VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU"; + case 3: return "VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU"; + case 4: return "VK_PHYSICAL_DEVICE_TYPE_CPU"; + } + return NULL; +} +void print_VkPhysicalDeviceType(const VkPhysicalDeviceType* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkPhysicalDeviceType_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkQueueFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_QUEUE_GRAPHICS_BIT"; + case (1 << 1): return "VK_QUEUE_COMPUTE_BIT"; + case (1 << 2): return "VK_QUEUE_TRANSFER_BIT"; + case (1 << 4): return "VK_QUEUE_PROTECTED_BIT"; + case (1 << 5): return "VK_QUEUE_VIDEO_DECODE_BIT_KHR"; + case (1 << 6): return "VK_QUEUE_VIDEO_ENCODE_BIT_KHR"; + } + return NULL; +} +void print_VkQueueFlagBits(const VkQueueFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkQueueFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +#ifdef VK_VERSION_1_1 +static const char* VkDeviceQueueCreateFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT"; + } + return NULL; +} +void print_VkDeviceQueueCreateFlagBits(const VkDeviceQueueCreateFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkDeviceQueueCreateFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +#endif +static const char* VkPipelineStageFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT"; + case (1 << 1): return "VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT"; + case (1 << 2): return "VK_PIPELINE_STAGE_VERTEX_INPUT_BIT"; + case (1 << 3): return "VK_PIPELINE_STAGE_VERTEX_SHADER_BIT"; + case (1 << 4): return "VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT"; + case (1 << 5): return "VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT"; + case (1 << 6): return "VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT"; + case (1 << 7): return "VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT"; + case (1 << 8): return "VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT"; + case (1 << 9): return "VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT"; + case (1 << 10): return "VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT"; + case (1 << 11): return "VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT"; + case (1 << 12): return "VK_PIPELINE_STAGE_TRANSFER_BIT"; + case (1 << 13): return "VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT"; + case (1 << 14): return "VK_PIPELINE_STAGE_HOST_BIT"; + case (1 << 15): return "VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT"; + case (1 << 16): return "VK_PIPELINE_STAGE_ALL_COMMANDS_BIT"; + case (1 << 24): return "VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT"; + case (1 << 18): return "VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT"; + case (1 << 25): return "VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR"; + case (1 << 21): return "VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR"; + case (1 << 19): return "VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV"; + case (1 << 20): return "VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV"; + case (1 << 23): return "VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT"; + case (1 << 22): return "VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; + case (1 << 17): return "VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV"; + case 0: return "VK_PIPELINE_STAGE_NONE_KHR"; + } + return NULL; +} +void print_VkPipelineStageFlagBits(const VkPipelineStageFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkPipelineStageFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkFenceCreateFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_FENCE_CREATE_SIGNALED_BIT"; + } + return NULL; +} +void print_VkFenceCreateFlagBits(const VkFenceCreateFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkFenceCreateFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkEventCreateFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR"; + } + return NULL; +} +void print_VkEventCreateFlagBits(const VkEventCreateFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkEventCreateFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkQueryPipelineStatisticFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT"; + case (1 << 1): return "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT"; + case (1 << 2): return "VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT"; + case (1 << 3): return "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT"; + case (1 << 4): return "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT"; + case (1 << 5): return "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT"; + case (1 << 6): return "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT"; + case (1 << 7): return "VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT"; + case (1 << 8): return "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT"; + case (1 << 9): return "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT"; + case (1 << 10): return "VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT"; + } + return NULL; +} +void print_VkQueryPipelineStatisticFlagBits(const VkQueryPipelineStatisticFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkQueryPipelineStatisticFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkQueryType_map(int o) { +switch (o) { + case 0: return "VK_QUERY_TYPE_OCCLUSION"; + case 1: return "VK_QUERY_TYPE_PIPELINE_STATISTICS"; + case 2: return "VK_QUERY_TYPE_TIMESTAMP"; + case 1000023000: return "VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR"; + case 1000028004: return "VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT"; + case 1000116000: return "VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR"; + case 1000150000: return "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR"; + case 1000150001: return "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR"; + case 1000165000: return "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV"; + case 1000210000: return "VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL"; + case 1000299000: return "VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR"; + } + return NULL; +} +void print_VkQueryType(const VkQueryType* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkQueryType_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkQueryResultFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_QUERY_RESULT_64_BIT"; + case (1 << 1): return "VK_QUERY_RESULT_WAIT_BIT"; + case (1 << 2): return "VK_QUERY_RESULT_WITH_AVAILABILITY_BIT"; + case (1 << 3): return "VK_QUERY_RESULT_PARTIAL_BIT"; + case (1 << 4): return "VK_QUERY_RESULT_WITH_STATUS_BIT_KHR"; + } + return NULL; +} +void print_VkQueryResultFlagBits(const VkQueryResultFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkQueryResultFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkBufferCreateFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_BUFFER_CREATE_SPARSE_BINDING_BIT"; + case (1 << 1): return "VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT"; + case (1 << 2): return "VK_BUFFER_CREATE_SPARSE_ALIASED_BIT"; + case (1 << 3): return "VK_BUFFER_CREATE_PROTECTED_BIT"; + case (1 << 4): return "VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT"; + case (1 << 5): return "VK_BUFFER_CREATE_RESERVED_5_BIT_AMD"; + } + return NULL; +} +void print_VkBufferCreateFlagBits(const VkBufferCreateFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkBufferCreateFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkBufferUsageFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_BUFFER_USAGE_TRANSFER_SRC_BIT"; + case (1 << 1): return "VK_BUFFER_USAGE_TRANSFER_DST_BIT"; + case (1 << 2): return "VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT"; + case (1 << 3): return "VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT"; + case (1 << 4): return "VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT"; + case (1 << 5): return "VK_BUFFER_USAGE_STORAGE_BUFFER_BIT"; + case (1 << 6): return "VK_BUFFER_USAGE_INDEX_BUFFER_BIT"; + case (1 << 7): return "VK_BUFFER_USAGE_VERTEX_BUFFER_BIT"; + case (1 << 8): return "VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT"; + case (1 << 17): return "VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT"; + case (1 << 13): return "VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR"; + case (1 << 14): return "VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR"; + case (1 << 11): return "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT"; + case (1 << 12): return "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT"; + case (1 << 9): return "VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT"; + case (1 << 19): return "VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR"; + case (1 << 20): return "VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR"; + case (1 << 10): return "VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR"; + case (1 << 18): return "VK_BUFFER_USAGE_RESERVED_18_BIT_QCOM"; + case (1 << 15): return "VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR"; + case (1 << 16): return "VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR"; + case (1 << 21): return "VK_BUFFER_USAGE_RESERVED_21_BIT_AMD"; + case (1 << 22): return "VK_BUFFER_USAGE_RESERVED_22_BIT_AMD"; + } + return NULL; +} +void print_VkBufferUsageFlagBits(const VkBufferUsageFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkBufferUsageFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkSharingMode_map(int o) { +switch (o) { + case 0: return "VK_SHARING_MODE_EXCLUSIVE"; + case 1: return "VK_SHARING_MODE_CONCURRENT"; + } + return NULL; +} +void print_VkSharingMode(const VkSharingMode* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkSharingMode_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkComponentSwizzle_map(int o) { +switch (o) { + case 0: return "VK_COMPONENT_SWIZZLE_IDENTITY"; + case 1: return "VK_COMPONENT_SWIZZLE_ZERO"; + case 2: return "VK_COMPONENT_SWIZZLE_ONE"; + case 3: return "VK_COMPONENT_SWIZZLE_R"; + case 4: return "VK_COMPONENT_SWIZZLE_G"; + case 5: return "VK_COMPONENT_SWIZZLE_B"; + case 6: return "VK_COMPONENT_SWIZZLE_A"; + } + return NULL; +} +void print_VkComponentSwizzle(const VkComponentSwizzle* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkComponentSwizzle_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkImageViewCreateFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT"; + case (1 << 1): return "VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT"; + } + return NULL; +} +void print_VkImageViewCreateFlagBits(const VkImageViewCreateFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkImageViewCreateFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkImageViewType_map(int o) { +switch (o) { + case 0: return "VK_IMAGE_VIEW_TYPE_1D"; + case 1: return "VK_IMAGE_VIEW_TYPE_2D"; + case 2: return "VK_IMAGE_VIEW_TYPE_3D"; + case 3: return "VK_IMAGE_VIEW_TYPE_CUBE"; + case 4: return "VK_IMAGE_VIEW_TYPE_1D_ARRAY"; + case 5: return "VK_IMAGE_VIEW_TYPE_2D_ARRAY"; + case 6: return "VK_IMAGE_VIEW_TYPE_CUBE_ARRAY"; + } + return NULL; +} +void print_VkImageViewType(const VkImageViewType* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkImageViewType_map(*obj), commaNeeded ? "," : ""); +} + +#ifdef VKSC_VERSION_1_0 +static const char* VkPipelineCacheCreateFlagBits_map(int o) { +switch (o) { + case (1 << 2): return "VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT"; + case (1 << 1): return "VK_PIPELINE_CACHE_CREATE_RESERVED_1_BIT_EXT"; + case (1 << 0): return "VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT"; + } + return NULL; +} +void print_VkPipelineCacheCreateFlagBits(const VkPipelineCacheCreateFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkPipelineCacheCreateFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +#endif +static const char* VkBlendFactor_map(int o) { +switch (o) { + case 0: return "VK_BLEND_FACTOR_ZERO"; + case 1: return "VK_BLEND_FACTOR_ONE"; + case 2: return "VK_BLEND_FACTOR_SRC_COLOR"; + case 3: return "VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR"; + case 4: return "VK_BLEND_FACTOR_DST_COLOR"; + case 5: return "VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR"; + case 6: return "VK_BLEND_FACTOR_SRC_ALPHA"; + case 7: return "VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA"; + case 8: return "VK_BLEND_FACTOR_DST_ALPHA"; + case 9: return "VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA"; + case 10: return "VK_BLEND_FACTOR_CONSTANT_COLOR"; + case 11: return "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR"; + case 12: return "VK_BLEND_FACTOR_CONSTANT_ALPHA"; + case 13: return "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA"; + case 14: return "VK_BLEND_FACTOR_SRC_ALPHA_SATURATE"; + case 15: return "VK_BLEND_FACTOR_SRC1_COLOR"; + case 16: return "VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR"; + case 17: return "VK_BLEND_FACTOR_SRC1_ALPHA"; + case 18: return "VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA"; + } + return NULL; +} +void print_VkBlendFactor(const VkBlendFactor* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkBlendFactor_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkBlendOp_map(int o) { +switch (o) { + case 0: return "VK_BLEND_OP_ADD"; + case 1: return "VK_BLEND_OP_SUBTRACT"; + case 2: return "VK_BLEND_OP_REVERSE_SUBTRACT"; + case 3: return "VK_BLEND_OP_MIN"; + case 4: return "VK_BLEND_OP_MAX"; + case 1000148000: return "VK_BLEND_OP_ZERO_EXT"; + case 1000148001: return "VK_BLEND_OP_SRC_EXT"; + case 1000148002: return "VK_BLEND_OP_DST_EXT"; + case 1000148003: return "VK_BLEND_OP_SRC_OVER_EXT"; + case 1000148004: return "VK_BLEND_OP_DST_OVER_EXT"; + case 1000148005: return "VK_BLEND_OP_SRC_IN_EXT"; + case 1000148006: return "VK_BLEND_OP_DST_IN_EXT"; + case 1000148007: return "VK_BLEND_OP_SRC_OUT_EXT"; + case 1000148008: return "VK_BLEND_OP_DST_OUT_EXT"; + case 1000148009: return "VK_BLEND_OP_SRC_ATOP_EXT"; + case 1000148010: return "VK_BLEND_OP_DST_ATOP_EXT"; + case 1000148011: return "VK_BLEND_OP_XOR_EXT"; + case 1000148012: return "VK_BLEND_OP_MULTIPLY_EXT"; + case 1000148013: return "VK_BLEND_OP_SCREEN_EXT"; + case 1000148014: return "VK_BLEND_OP_OVERLAY_EXT"; + case 1000148015: return "VK_BLEND_OP_DARKEN_EXT"; + case 1000148016: return "VK_BLEND_OP_LIGHTEN_EXT"; + case 1000148017: return "VK_BLEND_OP_COLORDODGE_EXT"; + case 1000148018: return "VK_BLEND_OP_COLORBURN_EXT"; + case 1000148019: return "VK_BLEND_OP_HARDLIGHT_EXT"; + case 1000148020: return "VK_BLEND_OP_SOFTLIGHT_EXT"; + case 1000148021: return "VK_BLEND_OP_DIFFERENCE_EXT"; + case 1000148022: return "VK_BLEND_OP_EXCLUSION_EXT"; + case 1000148023: return "VK_BLEND_OP_INVERT_EXT"; + case 1000148024: return "VK_BLEND_OP_INVERT_RGB_EXT"; + case 1000148025: return "VK_BLEND_OP_LINEARDODGE_EXT"; + case 1000148026: return "VK_BLEND_OP_LINEARBURN_EXT"; + case 1000148027: return "VK_BLEND_OP_VIVIDLIGHT_EXT"; + case 1000148028: return "VK_BLEND_OP_LINEARLIGHT_EXT"; + case 1000148029: return "VK_BLEND_OP_PINLIGHT_EXT"; + case 1000148030: return "VK_BLEND_OP_HARDMIX_EXT"; + case 1000148031: return "VK_BLEND_OP_HSL_HUE_EXT"; + case 1000148032: return "VK_BLEND_OP_HSL_SATURATION_EXT"; + case 1000148033: return "VK_BLEND_OP_HSL_COLOR_EXT"; + case 1000148034: return "VK_BLEND_OP_HSL_LUMINOSITY_EXT"; + case 1000148035: return "VK_BLEND_OP_PLUS_EXT"; + case 1000148036: return "VK_BLEND_OP_PLUS_CLAMPED_EXT"; + case 1000148037: return "VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT"; + case 1000148038: return "VK_BLEND_OP_PLUS_DARKER_EXT"; + case 1000148039: return "VK_BLEND_OP_MINUS_EXT"; + case 1000148040: return "VK_BLEND_OP_MINUS_CLAMPED_EXT"; + case 1000148041: return "VK_BLEND_OP_CONTRAST_EXT"; + case 1000148042: return "VK_BLEND_OP_INVERT_OVG_EXT"; + case 1000148043: return "VK_BLEND_OP_RED_EXT"; + case 1000148044: return "VK_BLEND_OP_GREEN_EXT"; + case 1000148045: return "VK_BLEND_OP_BLUE_EXT"; + } + return NULL; +} +void print_VkBlendOp(const VkBlendOp* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkBlendOp_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkColorComponentFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_COLOR_COMPONENT_R_BIT"; + case (1 << 1): return "VK_COLOR_COMPONENT_G_BIT"; + case (1 << 2): return "VK_COLOR_COMPONENT_B_BIT"; + case (1 << 3): return "VK_COLOR_COMPONENT_A_BIT"; + } + return NULL; +} +void print_VkColorComponentFlagBits(const VkColorComponentFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkColorComponentFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkCompareOp_map(int o) { +switch (o) { + case 0: return "VK_COMPARE_OP_NEVER"; + case 1: return "VK_COMPARE_OP_LESS"; + case 2: return "VK_COMPARE_OP_EQUAL"; + case 3: return "VK_COMPARE_OP_LESS_OR_EQUAL"; + case 4: return "VK_COMPARE_OP_GREATER"; + case 5: return "VK_COMPARE_OP_NOT_EQUAL"; + case 6: return "VK_COMPARE_OP_GREATER_OR_EQUAL"; + case 7: return "VK_COMPARE_OP_ALWAYS"; + } + return NULL; +} +void print_VkCompareOp(const VkCompareOp* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkCompareOp_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkPipelineCreateFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT"; + case (1 << 3): return "VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT"; + case (1 << 4): return "VK_PIPELINE_CREATE_DISPATCH_BASE_BIT"; + case (1 << 21): return "VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; + case (1 << 22): return "VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"; + case (1 << 14): return "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR"; + case (1 << 15): return "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR"; + case (1 << 16): return "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR"; + case (1 << 17): return "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR"; + case (1 << 12): return "VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR"; + case (1 << 13): return "VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR"; + case (1 << 19): return "VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR"; + case (1 << 5): return "VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV"; + case (1 << 6): return "VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR"; + case (1 << 7): return "VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR"; + case (1 << 18): return "VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV"; + case (1 << 11): return "VK_PIPELINE_CREATE_LIBRARY_BIT_KHR"; + case (1 << 8): return "VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT"; + case (1 << 9): return "VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT"; + case (1 << 23): return "VK_PIPELINE_CREATE_RESERVED_23_BIT_AMD"; + case (1 << 10): return "VK_PIPELINE_CREATE_RESERVED_10_BIT_AMD"; + case (1 << 20): return "VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV"; + } + return NULL; +} +void print_VkPipelineCreateFlagBits(const VkPipelineCreateFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkPipelineCreateFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkPipelineShaderStageCreateFlagBits_map(int o) { +switch (o) { + case (1 << 2): return "VK_PIPELINE_SHADER_STAGE_CREATE_RESERVED_2_BIT_NV"; + case (1 << 0): return "VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT"; + case (1 << 1): return "VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT"; + case (1 << 3): return "VK_PIPELINE_SHADER_STAGE_CREATE_RESERVED_3_BIT_KHR"; + } + return NULL; +} +void print_VkPipelineShaderStageCreateFlagBits(const VkPipelineShaderStageCreateFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkPipelineShaderStageCreateFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkShaderStageFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_SHADER_STAGE_VERTEX_BIT"; + case (1 << 1): return "VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT"; + case (1 << 2): return "VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT"; + case (1 << 3): return "VK_SHADER_STAGE_GEOMETRY_BIT"; + case (1 << 4): return "VK_SHADER_STAGE_FRAGMENT_BIT"; + case (1 << 5): return "VK_SHADER_STAGE_COMPUTE_BIT"; + case 0x0000001F: return "VK_SHADER_STAGE_ALL_GRAPHICS"; + case 0x7FFFFFFF: return "VK_SHADER_STAGE_ALL"; + case (1 << 8): return "VK_SHADER_STAGE_RAYGEN_BIT_KHR"; + case (1 << 9): return "VK_SHADER_STAGE_ANY_HIT_BIT_KHR"; + case (1 << 10): return "VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR"; + case (1 << 11): return "VK_SHADER_STAGE_MISS_BIT_KHR"; + case (1 << 12): return "VK_SHADER_STAGE_INTERSECTION_BIT_KHR"; + case (1 << 13): return "VK_SHADER_STAGE_CALLABLE_BIT_KHR"; + case (1 << 6): return "VK_SHADER_STAGE_TASK_BIT_NV"; + case (1 << 7): return "VK_SHADER_STAGE_MESH_BIT_NV"; + case (1 << 14): return "VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI"; + } + return NULL; +} +void print_VkShaderStageFlagBits(const VkShaderStageFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkShaderStageFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkCullModeFlagBits_map(int o) { +switch (o) { + case 0: return "VK_CULL_MODE_NONE"; + case (1 << 0): return "VK_CULL_MODE_FRONT_BIT"; + case (1 << 1): return "VK_CULL_MODE_BACK_BIT"; + case 0x00000003: return "VK_CULL_MODE_FRONT_AND_BACK"; + } + return NULL; +} +void print_VkCullModeFlagBits(const VkCullModeFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkCullModeFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkDynamicState_map(int o) { +switch (o) { + case 0: return "VK_DYNAMIC_STATE_VIEWPORT"; + case 1: return "VK_DYNAMIC_STATE_SCISSOR"; + case 2: return "VK_DYNAMIC_STATE_LINE_WIDTH"; + case 3: return "VK_DYNAMIC_STATE_DEPTH_BIAS"; + case 4: return "VK_DYNAMIC_STATE_BLEND_CONSTANTS"; + case 5: return "VK_DYNAMIC_STATE_DEPTH_BOUNDS"; + case 6: return "VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK"; + case 7: return "VK_DYNAMIC_STATE_STENCIL_WRITE_MASK"; + case 8: return "VK_DYNAMIC_STATE_STENCIL_REFERENCE"; + case 1000087000: return "VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV"; + case 1000099000: return "VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT"; + case 1000143000: return "VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT"; + case 1000347000: return "VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR"; + case 1000164004: return "VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV"; + case 1000164006: return "VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV"; + case 1000205001: return "VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV"; + case 1000226000: return "VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR"; + case 1000259000: return "VK_DYNAMIC_STATE_LINE_STIPPLE_EXT"; + case 1000267000: return "VK_DYNAMIC_STATE_CULL_MODE_EXT"; + case 1000267001: return "VK_DYNAMIC_STATE_FRONT_FACE_EXT"; + case 1000267002: return "VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT"; + case 1000267003: return "VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT"; + case 1000267004: return "VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT"; + case 1000267005: return "VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT"; + case 1000267006: return "VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT"; + case 1000267007: return "VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT"; + case 1000267008: return "VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT"; + case 1000267009: return "VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT"; + case 1000267010: return "VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT"; + case 1000267011: return "VK_DYNAMIC_STATE_STENCIL_OP_EXT"; + case 1000352000: return "VK_DYNAMIC_STATE_VERTEX_INPUT_EXT"; + case 1000377000: return "VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT"; + case 1000377001: return "VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT"; + case 1000377002: return "VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT"; + case 1000377003: return "VK_DYNAMIC_STATE_LOGIC_OP_EXT"; + case 1000377004: return "VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT"; + case 1000381000: return "VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT"; + } + return NULL; +} +void print_VkDynamicState(const VkDynamicState* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkDynamicState_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkFrontFace_map(int o) { +switch (o) { + case 0: return "VK_FRONT_FACE_COUNTER_CLOCKWISE"; + case 1: return "VK_FRONT_FACE_CLOCKWISE"; + } + return NULL; +} +void print_VkFrontFace(const VkFrontFace* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkFrontFace_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkVertexInputRate_map(int o) { +switch (o) { + case 0: return "VK_VERTEX_INPUT_RATE_VERTEX"; + case 1: return "VK_VERTEX_INPUT_RATE_INSTANCE"; + } + return NULL; +} +void print_VkVertexInputRate(const VkVertexInputRate* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkVertexInputRate_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkPrimitiveTopology_map(int o) { +switch (o) { + case 0: return "VK_PRIMITIVE_TOPOLOGY_POINT_LIST"; + case 1: return "VK_PRIMITIVE_TOPOLOGY_LINE_LIST"; + case 2: return "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP"; + case 3: return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST"; + case 4: return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP"; + case 5: return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN"; + case 6: return "VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY"; + case 7: return "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY"; + case 8: return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY"; + case 9: return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY"; + case 10: return "VK_PRIMITIVE_TOPOLOGY_PATCH_LIST"; + } + return NULL; +} +void print_VkPrimitiveTopology(const VkPrimitiveTopology* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkPrimitiveTopology_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkPolygonMode_map(int o) { +switch (o) { + case 0: return "VK_POLYGON_MODE_FILL"; + case 1: return "VK_POLYGON_MODE_LINE"; + case 2: return "VK_POLYGON_MODE_POINT"; + case 1000153000: return "VK_POLYGON_MODE_FILL_RECTANGLE_NV"; + } + return NULL; +} +void print_VkPolygonMode(const VkPolygonMode* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkPolygonMode_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkStencilOp_map(int o) { +switch (o) { + case 0: return "VK_STENCIL_OP_KEEP"; + case 1: return "VK_STENCIL_OP_ZERO"; + case 2: return "VK_STENCIL_OP_REPLACE"; + case 3: return "VK_STENCIL_OP_INCREMENT_AND_CLAMP"; + case 4: return "VK_STENCIL_OP_DECREMENT_AND_CLAMP"; + case 5: return "VK_STENCIL_OP_INVERT"; + case 6: return "VK_STENCIL_OP_INCREMENT_AND_WRAP"; + case 7: return "VK_STENCIL_OP_DECREMENT_AND_WRAP"; + } + return NULL; +} +void print_VkStencilOp(const VkStencilOp* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkStencilOp_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkLogicOp_map(int o) { +switch (o) { + case 0: return "VK_LOGIC_OP_CLEAR"; + case 1: return "VK_LOGIC_OP_AND"; + case 2: return "VK_LOGIC_OP_AND_REVERSE"; + case 3: return "VK_LOGIC_OP_COPY"; + case 4: return "VK_LOGIC_OP_AND_INVERTED"; + case 5: return "VK_LOGIC_OP_NO_OP"; + case 6: return "VK_LOGIC_OP_XOR"; + case 7: return "VK_LOGIC_OP_OR"; + case 8: return "VK_LOGIC_OP_NOR"; + case 9: return "VK_LOGIC_OP_EQUIVALENT"; + case 10: return "VK_LOGIC_OP_INVERT"; + case 11: return "VK_LOGIC_OP_OR_REVERSE"; + case 12: return "VK_LOGIC_OP_COPY_INVERTED"; + case 13: return "VK_LOGIC_OP_OR_INVERTED"; + case 14: return "VK_LOGIC_OP_NAND"; + case 15: return "VK_LOGIC_OP_SET"; + } + return NULL; +} +void print_VkLogicOp(const VkLogicOp* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkLogicOp_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkBorderColor_map(int o) { +switch (o) { + case 0: return "VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK"; + case 1: return "VK_BORDER_COLOR_INT_TRANSPARENT_BLACK"; + case 2: return "VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK"; + case 3: return "VK_BORDER_COLOR_INT_OPAQUE_BLACK"; + case 4: return "VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE"; + case 5: return "VK_BORDER_COLOR_INT_OPAQUE_WHITE"; + case 1000287003: return "VK_BORDER_COLOR_FLOAT_CUSTOM_EXT"; + case 1000287004: return "VK_BORDER_COLOR_INT_CUSTOM_EXT"; + } + return NULL; +} +void print_VkBorderColor(const VkBorderColor* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkBorderColor_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkFilter_map(int o) { +switch (o) { + case 0: return "VK_FILTER_NEAREST"; + case 1: return "VK_FILTER_LINEAR"; + case 1000015000: return "VK_FILTER_CUBIC_IMG"; + } + return NULL; +} +void print_VkFilter(const VkFilter* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkFilter_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkSamplerAddressMode_map(int o) { +switch (o) { + case 0: return "VK_SAMPLER_ADDRESS_MODE_REPEAT"; + case 1: return "VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT"; + case 2: return "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE"; + case 3: return "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER"; + case 4: return "VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE"; + } + return NULL; +} +void print_VkSamplerAddressMode(const VkSamplerAddressMode* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkSamplerAddressMode_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkSamplerCreateFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT"; + case (1 << 1): return "VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT"; + case (1 << 3): return "VK_SAMPLER_CREATE_RESERVED_3_BIT_AMD"; + case (1 << 2): return "VK_SAMPLER_CREATE_RESERVED_2_BIT_EXT"; + } + return NULL; +} +void print_VkSamplerCreateFlagBits(const VkSamplerCreateFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkSamplerCreateFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkSamplerMipmapMode_map(int o) { +switch (o) { + case 0: return "VK_SAMPLER_MIPMAP_MODE_NEAREST"; + case 1: return "VK_SAMPLER_MIPMAP_MODE_LINEAR"; + } + return NULL; +} +void print_VkSamplerMipmapMode(const VkSamplerMipmapMode* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkSamplerMipmapMode_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkDescriptorPoolCreateFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT"; + case (1 << 1): return "VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT"; + case (1 << 2): return "VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE"; + } + return NULL; +} +void print_VkDescriptorPoolCreateFlagBits(const VkDescriptorPoolCreateFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkDescriptorPoolCreateFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkDescriptorType_map(int o) { +switch (o) { + case 0: return "VK_DESCRIPTOR_TYPE_SAMPLER"; + case 1: return "VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER"; + case 2: return "VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE"; + case 3: return "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE"; + case 4: return "VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER"; + case 5: return "VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER"; + case 6: return "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER"; + case 7: return "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER"; + case 8: return "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC"; + case 9: return "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC"; + case 10: return "VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT"; + case 1000138000: return "VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT"; + case 1000150000: return "VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR"; + case 1000165000: return "VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV"; + case 1000351000: return "VK_DESCRIPTOR_TYPE_MUTABLE_VALVE"; + } + return NULL; +} +void print_VkDescriptorType(const VkDescriptorType* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkDescriptorType_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkDescriptorSetLayoutCreateFlagBits_map(int o) { +switch (o) { + case (1 << 1): return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT"; + case (1 << 0): return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR"; + case (1 << 4): return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_RESERVED_4_BIT_AMD"; + case (1 << 3): return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_RESERVED_3_BIT_AMD"; + case (1 << 2): return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE"; + } + return NULL; +} +void print_VkDescriptorSetLayoutCreateFlagBits(const VkDescriptorSetLayoutCreateFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkDescriptorSetLayoutCreateFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkAttachmentDescriptionFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT"; + } + return NULL; +} +void print_VkAttachmentDescriptionFlagBits(const VkAttachmentDescriptionFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkAttachmentDescriptionFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkAttachmentLoadOp_map(int o) { +switch (o) { + case 0: return "VK_ATTACHMENT_LOAD_OP_LOAD"; + case 1: return "VK_ATTACHMENT_LOAD_OP_CLEAR"; + case 2: return "VK_ATTACHMENT_LOAD_OP_DONT_CARE"; + case 1000400000: return "VK_ATTACHMENT_LOAD_OP_NONE_EXT"; + } + return NULL; +} +void print_VkAttachmentLoadOp(const VkAttachmentLoadOp* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkAttachmentLoadOp_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkAttachmentStoreOp_map(int o) { +switch (o) { + case 0: return "VK_ATTACHMENT_STORE_OP_STORE"; + case 1: return "VK_ATTACHMENT_STORE_OP_DONT_CARE"; + case 1000301000: return "VK_ATTACHMENT_STORE_OP_NONE_KHR"; + } + return NULL; +} +void print_VkAttachmentStoreOp(const VkAttachmentStoreOp* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkAttachmentStoreOp_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkDependencyFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_DEPENDENCY_BY_REGION_BIT"; + case (1 << 2): return "VK_DEPENDENCY_DEVICE_GROUP_BIT"; + case (1 << 1): return "VK_DEPENDENCY_VIEW_LOCAL_BIT"; + } + return NULL; +} +void print_VkDependencyFlagBits(const VkDependencyFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkDependencyFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkFramebufferCreateFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT"; + } + return NULL; +} +void print_VkFramebufferCreateFlagBits(const VkFramebufferCreateFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkFramebufferCreateFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkPipelineBindPoint_map(int o) { +switch (o) { + case 0: return "VK_PIPELINE_BIND_POINT_GRAPHICS"; + case 1: return "VK_PIPELINE_BIND_POINT_COMPUTE"; + case 1000165000: return "VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR"; + case 1000369003: return "VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI"; + } + return NULL; +} +void print_VkPipelineBindPoint(const VkPipelineBindPoint* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkPipelineBindPoint_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkRenderPassCreateFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_RENDER_PASS_CREATE_RESERVED_0_BIT_KHR"; + case (1 << 1): return "VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM"; + } + return NULL; +} +void print_VkRenderPassCreateFlagBits(const VkRenderPassCreateFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkRenderPassCreateFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkSubpassDescriptionFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX"; + case (1 << 1): return "VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX"; + case (1 << 2): return "VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM"; + case (1 << 3): return "VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM"; + case (1 << 4): return "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM"; + case (1 << 5): return "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM"; + case (1 << 6): return "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM"; + } + return NULL; +} +void print_VkSubpassDescriptionFlagBits(const VkSubpassDescriptionFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkSubpassDescriptionFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkCommandPoolCreateFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_COMMAND_POOL_CREATE_TRANSIENT_BIT"; + case (1 << 1): return "VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT"; + case (1 << 2): return "VK_COMMAND_POOL_CREATE_PROTECTED_BIT"; + } + return NULL; +} +void print_VkCommandPoolCreateFlagBits(const VkCommandPoolCreateFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkCommandPoolCreateFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkCommandPoolResetFlagBits_map(int o) { +switch (o) { + case (1 << 1): return "VK_COMMAND_POOL_RESET_RESERVED_1_BIT_COREAVI"; + } + return NULL; +} +void print_VkCommandPoolResetFlagBits(const VkCommandPoolResetFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkCommandPoolResetFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkCommandBufferLevel_map(int o) { +switch (o) { + case 0: return "VK_COMMAND_BUFFER_LEVEL_PRIMARY"; + case 1: return "VK_COMMAND_BUFFER_LEVEL_SECONDARY"; + } + return NULL; +} +void print_VkCommandBufferLevel(const VkCommandBufferLevel* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkCommandBufferLevel_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkCommandBufferUsageFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT"; + case (1 << 1): return "VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT"; + case (1 << 2): return "VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT"; + } + return NULL; +} +void print_VkCommandBufferUsageFlagBits(const VkCommandBufferUsageFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkCommandBufferUsageFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkQueryControlFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_QUERY_CONTROL_PRECISE_BIT"; + } + return NULL; +} +void print_VkQueryControlFlagBits(const VkQueryControlFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkQueryControlFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkCommandBufferResetFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT"; + } + return NULL; +} +void print_VkCommandBufferResetFlagBits(const VkCommandBufferResetFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkCommandBufferResetFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkIndexType_map(int o) { +switch (o) { + case 0: return "VK_INDEX_TYPE_UINT16"; + case 1: return "VK_INDEX_TYPE_UINT32"; + case 1000165000: return "VK_INDEX_TYPE_NONE_KHR"; + case 1000265000: return "VK_INDEX_TYPE_UINT8_EXT"; + } + return NULL; +} +void print_VkIndexType(const VkIndexType* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkIndexType_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkStencilFaceFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_STENCIL_FACE_FRONT_BIT"; + case (1 << 1): return "VK_STENCIL_FACE_BACK_BIT"; + case 0x00000003: return "VK_STENCIL_FACE_FRONT_AND_BACK"; + } + return NULL; +} +void print_VkStencilFaceFlagBits(const VkStencilFaceFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkStencilFaceFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +static const char* VkSubpassContents_map(int o) { +switch (o) { + case 0: return "VK_SUBPASS_CONTENTS_INLINE"; + case 1: return "VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS"; + } + return NULL; +} +void print_VkSubpassContents(const VkSubpassContents* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkSubpassContents_map(*obj), commaNeeded ? "," : ""); +} + +void print_VkAccessFlags(const VkAccessFlags * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : ", str); + const unsigned int max_bits = 64; + unsigned int _count = 0; + unsigned int checkBit = 1; + unsigned int n = *obj; + while (n) { + n &= (n-1); + _count++; + } + unsigned int b = *obj; + checkBit = 1; + vk_json_printf(_OUT, "\""); + if (*obj == 0) vk_json_printf(_OUT, "0"); + for (unsigned int i = 0, bitCount = 0; i < max_bits; i++, checkBit <<= 1) { + unsigned int res = b & checkBit; + if (res) { + bitCount++; + if (bitCount < _count) { + vk_json_printf(_OUT, "%s | ", VkAccessFlagBits_map(1<width, "width", 1); + + print_uint32_t(&obj->height, "height", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkExtent3D(const VkExtent3D * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint32_t(&obj->width, "width", 1); + + print_uint32_t(&obj->height, "height", 1); + + print_uint32_t(&obj->depth, "depth", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkOffset2D(const VkOffset2D * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_int32_t(&obj->x, "x", 1); + + print_int32_t(&obj->y, "y", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkOffset3D(const VkOffset3D * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_int32_t(&obj->x, "x", 1); + + print_int32_t(&obj->y, "y", 1); + + print_int32_t(&obj->z, "z", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkRect2D(const VkRect2D * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + PRINT_SPACE + vk_json_printf(_OUT, "\"offset\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkOffset2D(&obj->offset, "offset", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"extent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->extent, "extent", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkBaseInStructure(const VkBaseInStructure * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkBaseOutStructure(const VkBaseOutStructure * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkBufferMemoryBarrier(const VkBufferMemoryBarrier * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkAccessFlags(&obj->srcAccessMask, "srcAccessMask", 1); + + print_VkAccessFlags(&obj->dstAccessMask, "dstAccessMask", 1); + + print_uint32_t(&obj->srcQueueFamilyIndex, "srcQueueFamilyIndex", 1); + + print_uint32_t(&obj->dstQueueFamilyIndex, "dstQueueFamilyIndex", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"buffer\" : \"\",\n"); + + print_VkDeviceSize(&obj->offset, "offset", 1); + + print_VkDeviceSize(&obj->size, "size", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkDispatchIndirectCommand(const VkDispatchIndirectCommand * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint32_t(&obj->x, "x", 1); + + print_uint32_t(&obj->y, "y", 1); + + print_uint32_t(&obj->z, "z", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkDrawIndexedIndirectCommand(const VkDrawIndexedIndirectCommand * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint32_t(&obj->indexCount, "indexCount", 1); + + print_uint32_t(&obj->instanceCount, "instanceCount", 1); + + print_uint32_t(&obj->firstIndex, "firstIndex", 1); + + print_int32_t(&obj->vertexOffset, "vertexOffset", 1); + + print_uint32_t(&obj->firstInstance, "firstInstance", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkDrawIndirectCommand(const VkDrawIndirectCommand * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint32_t(&obj->vertexCount, "vertexCount", 1); + + print_uint32_t(&obj->instanceCount, "instanceCount", 1); + + print_uint32_t(&obj->firstVertex, "firstVertex", 1); + + print_uint32_t(&obj->firstInstance, "firstInstance", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkImageSubresourceRange(const VkImageSubresourceRange * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkImageAspectFlags(&obj->aspectMask, "aspectMask", 1); + + print_uint32_t(&obj->baseMipLevel, "baseMipLevel", 1); + + print_uint32_t(&obj->levelCount, "levelCount", 1); + + print_uint32_t(&obj->baseArrayLayer, "baseArrayLayer", 1); + + print_uint32_t(&obj->layerCount, "layerCount", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkImageMemoryBarrier(const VkImageMemoryBarrier * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkAccessFlags(&obj->srcAccessMask, "srcAccessMask", 1); + + print_VkAccessFlags(&obj->dstAccessMask, "dstAccessMask", 1); + + print_VkImageLayout(&obj->oldLayout, "oldLayout", 1); + + print_VkImageLayout(&obj->newLayout, "newLayout", 1); + + print_uint32_t(&obj->srcQueueFamilyIndex, "srcQueueFamilyIndex", 1); + + print_uint32_t(&obj->dstQueueFamilyIndex, "dstQueueFamilyIndex", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"image\" : \"\",\n"); + + PRINT_SPACE + vk_json_printf(_OUT, "\"subresourceRange\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkImageSubresourceRange(&obj->subresourceRange, "subresourceRange", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkMemoryBarrier(const VkMemoryBarrier * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkAccessFlags(&obj->srcAccessMask, "srcAccessMask", 1); + + print_VkAccessFlags(&obj->dstAccessMask, "dstAccessMask", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkPipelineCacheHeaderVersionOne(const VkPipelineCacheHeaderVersionOne * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint32_t(&obj->headerSize, "headerSize", 1); + + print_VkPipelineCacheHeaderVersion(&obj->headerVersion, "headerVersion", 1); + + print_uint32_t(&obj->vendorID, "vendorID", 1); + + print_uint32_t(&obj->deviceID, "deviceID", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pipelineCacheUUID\" :"); + if (obj->pipelineCacheUUID) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_UUID_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "pipelineCacheUUID_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_UUID_SIZE); + print_uint8_t(&obj->pipelineCacheUUID[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkAllocationCallbacks(const VkAllocationCallbacks * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + /** Note: Ignoring void* data. **/ + + /** Note: Ignoring function pointer (PFN_vkAllocationFunction). **/ + + /** Note: Ignoring function pointer (PFN_vkReallocationFunction). **/ + + /** Note: Ignoring function pointer (PFN_vkFreeFunction). **/ + + /** Note: Ignoring function pointer (PFN_vkInternalAllocationNotification). **/ + + /** Note: Ignoring function pointer (PFN_vkInternalFreeNotification). **/ + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkApplicationInfo(const VkApplicationInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Printing string inline. **/ + PRINT_SPACE + vk_json_printf(_OUT, "\"pApplicationName\" : \"%s\",\n", (char*)obj->pApplicationName); + + print_uint32_t(&obj->applicationVersion, "applicationVersion", 1); + + /** Printing string inline. **/ + PRINT_SPACE + vk_json_printf(_OUT, "\"pEngineName\" : \"%s\",\n", (char*)obj->pEngineName); + + print_uint32_t(&obj->engineVersion, "engineVersion", 1); + + print_uint32_t(&obj->apiVersion, "apiVersion", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkFormatProperties(const VkFormatProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkFormatFeatureFlags(&obj->linearTilingFeatures, "linearTilingFeatures", 1); + + print_VkFormatFeatureFlags(&obj->optimalTilingFeatures, "optimalTilingFeatures", 1); + + print_VkFormatFeatureFlags(&obj->bufferFeatures, "bufferFeatures", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkImageFormatProperties(const VkImageFormatProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + PRINT_SPACE + vk_json_printf(_OUT, "\"maxExtent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent3D(&obj->maxExtent, "maxExtent", 1); + } + + print_uint32_t(&obj->maxMipLevels, "maxMipLevels", 1); + + print_uint32_t(&obj->maxArrayLayers, "maxArrayLayers", 1); + + print_VkSampleCountFlags(&obj->sampleCounts, "sampleCounts", 1); + + print_VkDeviceSize(&obj->maxResourceSize, "maxResourceSize", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkInstanceCreateInfo(const VkInstanceCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkInstanceCreateFlags(&obj->flags, "flags", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pApplicationInfo\" :"); + if (obj->pApplicationInfo) { + vk_json_printf(_OUT, "\n"); + print_VkApplicationInfo(*(&obj->pApplicationInfo), "pApplicationInfo", 1); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->enabledLayerCount, "enabledLayerCount", 1); + + /** Printing string inline. **/ + PRINT_SPACE + vk_json_printf(_OUT, "\"ppEnabledLayerNames\" : \"%s\",\n", (char*)obj->ppEnabledLayerNames); + + print_uint32_t(&obj->enabledExtensionCount, "enabledExtensionCount", 1); + + /** Printing string inline. **/ + PRINT_SPACE + vk_json_printf(_OUT, "\"ppEnabledExtensionNames\" : \"%s\",\n", (char*)obj->ppEnabledExtensionNames); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkMemoryHeap(const VkMemoryHeap * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkDeviceSize(&obj->size, "size", 1); + + print_VkMemoryHeapFlags(&obj->flags, "flags", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkMemoryType(const VkMemoryType * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkMemoryPropertyFlags(&obj->propertyFlags, "propertyFlags", 1); + + print_uint32_t(&obj->heapIndex, "heapIndex", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkPhysicalDeviceFeatures(const VkPhysicalDeviceFeatures * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkBool32(&obj->robustBufferAccess, "robustBufferAccess", 1); + + print_VkBool32(&obj->fullDrawIndexUint32, "fullDrawIndexUint32", 1); + + print_VkBool32(&obj->imageCubeArray, "imageCubeArray", 1); + + print_VkBool32(&obj->independentBlend, "independentBlend", 1); + + print_VkBool32(&obj->geometryShader, "geometryShader", 1); + + print_VkBool32(&obj->tessellationShader, "tessellationShader", 1); + + print_VkBool32(&obj->sampleRateShading, "sampleRateShading", 1); + + print_VkBool32(&obj->dualSrcBlend, "dualSrcBlend", 1); + + print_VkBool32(&obj->logicOp, "logicOp", 1); + + print_VkBool32(&obj->multiDrawIndirect, "multiDrawIndirect", 1); + + print_VkBool32(&obj->drawIndirectFirstInstance, "drawIndirectFirstInstance", 1); + + print_VkBool32(&obj->depthClamp, "depthClamp", 1); + + print_VkBool32(&obj->depthBiasClamp, "depthBiasClamp", 1); + + print_VkBool32(&obj->fillModeNonSolid, "fillModeNonSolid", 1); + + print_VkBool32(&obj->depthBounds, "depthBounds", 1); + + print_VkBool32(&obj->wideLines, "wideLines", 1); + + print_VkBool32(&obj->largePoints, "largePoints", 1); + + print_VkBool32(&obj->alphaToOne, "alphaToOne", 1); + + print_VkBool32(&obj->multiViewport, "multiViewport", 1); + + print_VkBool32(&obj->samplerAnisotropy, "samplerAnisotropy", 1); + + print_VkBool32(&obj->textureCompressionETC2, "textureCompressionETC2", 1); + + print_VkBool32(&obj->textureCompressionASTC_LDR, "textureCompressionASTC_LDR", 1); + + print_VkBool32(&obj->textureCompressionBC, "textureCompressionBC", 1); + + print_VkBool32(&obj->occlusionQueryPrecise, "occlusionQueryPrecise", 1); + + print_VkBool32(&obj->pipelineStatisticsQuery, "pipelineStatisticsQuery", 1); + + print_VkBool32(&obj->vertexPipelineStoresAndAtomics, "vertexPipelineStoresAndAtomics", 1); + + print_VkBool32(&obj->fragmentStoresAndAtomics, "fragmentStoresAndAtomics", 1); + + print_VkBool32(&obj->shaderTessellationAndGeometryPointSize, "shaderTessellationAndGeometryPointSize", 1); + + print_VkBool32(&obj->shaderImageGatherExtended, "shaderImageGatherExtended", 1); + + print_VkBool32(&obj->shaderStorageImageExtendedFormats, "shaderStorageImageExtendedFormats", 1); + + print_VkBool32(&obj->shaderStorageImageMultisample, "shaderStorageImageMultisample", 1); + + print_VkBool32(&obj->shaderStorageImageReadWithoutFormat, "shaderStorageImageReadWithoutFormat", 1); + + print_VkBool32(&obj->shaderStorageImageWriteWithoutFormat, "shaderStorageImageWriteWithoutFormat", 1); + + print_VkBool32(&obj->shaderUniformBufferArrayDynamicIndexing, "shaderUniformBufferArrayDynamicIndexing", 1); + + print_VkBool32(&obj->shaderSampledImageArrayDynamicIndexing, "shaderSampledImageArrayDynamicIndexing", 1); + + print_VkBool32(&obj->shaderStorageBufferArrayDynamicIndexing, "shaderStorageBufferArrayDynamicIndexing", 1); + + print_VkBool32(&obj->shaderStorageImageArrayDynamicIndexing, "shaderStorageImageArrayDynamicIndexing", 1); + + print_VkBool32(&obj->shaderClipDistance, "shaderClipDistance", 1); + + print_VkBool32(&obj->shaderCullDistance, "shaderCullDistance", 1); + + print_VkBool32(&obj->shaderFloat64, "shaderFloat64", 1); + + print_VkBool32(&obj->shaderInt64, "shaderInt64", 1); + + print_VkBool32(&obj->shaderInt16, "shaderInt16", 1); + + print_VkBool32(&obj->shaderResourceResidency, "shaderResourceResidency", 1); + + print_VkBool32(&obj->shaderResourceMinLod, "shaderResourceMinLod", 1); + + print_VkBool32(&obj->sparseBinding, "sparseBinding", 1); + + print_VkBool32(&obj->sparseResidencyBuffer, "sparseResidencyBuffer", 1); + + print_VkBool32(&obj->sparseResidencyImage2D, "sparseResidencyImage2D", 1); + + print_VkBool32(&obj->sparseResidencyImage3D, "sparseResidencyImage3D", 1); + + print_VkBool32(&obj->sparseResidency2Samples, "sparseResidency2Samples", 1); + + print_VkBool32(&obj->sparseResidency4Samples, "sparseResidency4Samples", 1); + + print_VkBool32(&obj->sparseResidency8Samples, "sparseResidency8Samples", 1); + + print_VkBool32(&obj->sparseResidency16Samples, "sparseResidency16Samples", 1); + + print_VkBool32(&obj->sparseResidencyAliased, "sparseResidencyAliased", 1); + + print_VkBool32(&obj->variableMultisampleRate, "variableMultisampleRate", 1); + + print_VkBool32(&obj->inheritedQueries, "inheritedQueries", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkPhysicalDeviceLimits(const VkPhysicalDeviceLimits * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint32_t(&obj->maxImageDimension1D, "maxImageDimension1D", 1); + + print_uint32_t(&obj->maxImageDimension2D, "maxImageDimension2D", 1); + + print_uint32_t(&obj->maxImageDimension3D, "maxImageDimension3D", 1); + + print_uint32_t(&obj->maxImageDimensionCube, "maxImageDimensionCube", 1); + + print_uint32_t(&obj->maxImageArrayLayers, "maxImageArrayLayers", 1); + + print_uint32_t(&obj->maxTexelBufferElements, "maxTexelBufferElements", 1); + + print_uint32_t(&obj->maxUniformBufferRange, "maxUniformBufferRange", 1); + + print_uint32_t(&obj->maxStorageBufferRange, "maxStorageBufferRange", 1); + + print_uint32_t(&obj->maxPushConstantsSize, "maxPushConstantsSize", 1); + + print_uint32_t(&obj->maxMemoryAllocationCount, "maxMemoryAllocationCount", 1); + + print_uint32_t(&obj->maxSamplerAllocationCount, "maxSamplerAllocationCount", 1); + + print_VkDeviceSize(&obj->bufferImageGranularity, "bufferImageGranularity", 1); + + print_VkDeviceSize(&obj->sparseAddressSpaceSize, "sparseAddressSpaceSize", 1); + + print_uint32_t(&obj->maxBoundDescriptorSets, "maxBoundDescriptorSets", 1); + + print_uint32_t(&obj->maxPerStageDescriptorSamplers, "maxPerStageDescriptorSamplers", 1); + + print_uint32_t(&obj->maxPerStageDescriptorUniformBuffers, "maxPerStageDescriptorUniformBuffers", 1); + + print_uint32_t(&obj->maxPerStageDescriptorStorageBuffers, "maxPerStageDescriptorStorageBuffers", 1); + + print_uint32_t(&obj->maxPerStageDescriptorSampledImages, "maxPerStageDescriptorSampledImages", 1); + + print_uint32_t(&obj->maxPerStageDescriptorStorageImages, "maxPerStageDescriptorStorageImages", 1); + + print_uint32_t(&obj->maxPerStageDescriptorInputAttachments, "maxPerStageDescriptorInputAttachments", 1); + + print_uint32_t(&obj->maxPerStageResources, "maxPerStageResources", 1); + + print_uint32_t(&obj->maxDescriptorSetSamplers, "maxDescriptorSetSamplers", 1); + + print_uint32_t(&obj->maxDescriptorSetUniformBuffers, "maxDescriptorSetUniformBuffers", 1); + + print_uint32_t(&obj->maxDescriptorSetUniformBuffersDynamic, "maxDescriptorSetUniformBuffersDynamic", 1); + + print_uint32_t(&obj->maxDescriptorSetStorageBuffers, "maxDescriptorSetStorageBuffers", 1); + + print_uint32_t(&obj->maxDescriptorSetStorageBuffersDynamic, "maxDescriptorSetStorageBuffersDynamic", 1); + + print_uint32_t(&obj->maxDescriptorSetSampledImages, "maxDescriptorSetSampledImages", 1); + + print_uint32_t(&obj->maxDescriptorSetStorageImages, "maxDescriptorSetStorageImages", 1); + + print_uint32_t(&obj->maxDescriptorSetInputAttachments, "maxDescriptorSetInputAttachments", 1); + + print_uint32_t(&obj->maxVertexInputAttributes, "maxVertexInputAttributes", 1); + + print_uint32_t(&obj->maxVertexInputBindings, "maxVertexInputBindings", 1); + + print_uint32_t(&obj->maxVertexInputAttributeOffset, "maxVertexInputAttributeOffset", 1); + + print_uint32_t(&obj->maxVertexInputBindingStride, "maxVertexInputBindingStride", 1); + + print_uint32_t(&obj->maxVertexOutputComponents, "maxVertexOutputComponents", 1); + + print_uint32_t(&obj->maxTessellationGenerationLevel, "maxTessellationGenerationLevel", 1); + + print_uint32_t(&obj->maxTessellationPatchSize, "maxTessellationPatchSize", 1); + + print_uint32_t(&obj->maxTessellationControlPerVertexInputComponents, "maxTessellationControlPerVertexInputComponents", 1); + + print_uint32_t(&obj->maxTessellationControlPerVertexOutputComponents, "maxTessellationControlPerVertexOutputComponents", 1); + + print_uint32_t(&obj->maxTessellationControlPerPatchOutputComponents, "maxTessellationControlPerPatchOutputComponents", 1); + + print_uint32_t(&obj->maxTessellationControlTotalOutputComponents, "maxTessellationControlTotalOutputComponents", 1); + + print_uint32_t(&obj->maxTessellationEvaluationInputComponents, "maxTessellationEvaluationInputComponents", 1); + + print_uint32_t(&obj->maxTessellationEvaluationOutputComponents, "maxTessellationEvaluationOutputComponents", 1); + + print_uint32_t(&obj->maxGeometryShaderInvocations, "maxGeometryShaderInvocations", 1); + + print_uint32_t(&obj->maxGeometryInputComponents, "maxGeometryInputComponents", 1); + + print_uint32_t(&obj->maxGeometryOutputComponents, "maxGeometryOutputComponents", 1); + + print_uint32_t(&obj->maxGeometryOutputVertices, "maxGeometryOutputVertices", 1); + + print_uint32_t(&obj->maxGeometryTotalOutputComponents, "maxGeometryTotalOutputComponents", 1); + + print_uint32_t(&obj->maxFragmentInputComponents, "maxFragmentInputComponents", 1); + + print_uint32_t(&obj->maxFragmentOutputAttachments, "maxFragmentOutputAttachments", 1); + + print_uint32_t(&obj->maxFragmentDualSrcAttachments, "maxFragmentDualSrcAttachments", 1); + + print_uint32_t(&obj->maxFragmentCombinedOutputResources, "maxFragmentCombinedOutputResources", 1); + + print_uint32_t(&obj->maxComputeSharedMemorySize, "maxComputeSharedMemorySize", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"maxComputeWorkGroupCount\" :"); + if (obj->maxComputeWorkGroupCount) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (3); i++) { + char tmp[100]; + sprintf(tmp, "maxComputeWorkGroupCount_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (3); + print_uint32_t(&obj->maxComputeWorkGroupCount[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->maxComputeWorkGroupInvocations, "maxComputeWorkGroupInvocations", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"maxComputeWorkGroupSize\" :"); + if (obj->maxComputeWorkGroupSize) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (3); i++) { + char tmp[100]; + sprintf(tmp, "maxComputeWorkGroupSize_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (3); + print_uint32_t(&obj->maxComputeWorkGroupSize[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->subPixelPrecisionBits, "subPixelPrecisionBits", 1); + + print_uint32_t(&obj->subTexelPrecisionBits, "subTexelPrecisionBits", 1); + + print_uint32_t(&obj->mipmapPrecisionBits, "mipmapPrecisionBits", 1); + + print_uint32_t(&obj->maxDrawIndexedIndexValue, "maxDrawIndexedIndexValue", 1); + + print_uint32_t(&obj->maxDrawIndirectCount, "maxDrawIndirectCount", 1); + + print_float(&obj->maxSamplerLodBias, "maxSamplerLodBias", 1); + + print_float(&obj->maxSamplerAnisotropy, "maxSamplerAnisotropy", 1); + + print_uint32_t(&obj->maxViewports, "maxViewports", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"maxViewportDimensions\" :"); + if (obj->maxViewportDimensions) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (2); i++) { + char tmp[100]; + sprintf(tmp, "maxViewportDimensions_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (2); + print_uint32_t(&obj->maxViewportDimensions[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"viewportBoundsRange\" :"); + if (obj->viewportBoundsRange) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (2); i++) { + char tmp[100]; + sprintf(tmp, "viewportBoundsRange_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (2); + print_float(&obj->viewportBoundsRange[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->viewportSubPixelBits, "viewportSubPixelBits", 1); + + print_size_t(&obj->minMemoryMapAlignment, "minMemoryMapAlignment", 1); + + print_VkDeviceSize(&obj->minTexelBufferOffsetAlignment, "minTexelBufferOffsetAlignment", 1); + + print_VkDeviceSize(&obj->minUniformBufferOffsetAlignment, "minUniformBufferOffsetAlignment", 1); + + print_VkDeviceSize(&obj->minStorageBufferOffsetAlignment, "minStorageBufferOffsetAlignment", 1); + + print_int32_t(&obj->minTexelOffset, "minTexelOffset", 1); + + print_uint32_t(&obj->maxTexelOffset, "maxTexelOffset", 1); + + print_int32_t(&obj->minTexelGatherOffset, "minTexelGatherOffset", 1); + + print_uint32_t(&obj->maxTexelGatherOffset, "maxTexelGatherOffset", 1); + + print_float(&obj->minInterpolationOffset, "minInterpolationOffset", 1); + + print_float(&obj->maxInterpolationOffset, "maxInterpolationOffset", 1); + + print_uint32_t(&obj->subPixelInterpolationOffsetBits, "subPixelInterpolationOffsetBits", 1); + + print_uint32_t(&obj->maxFramebufferWidth, "maxFramebufferWidth", 1); + + print_uint32_t(&obj->maxFramebufferHeight, "maxFramebufferHeight", 1); + + print_uint32_t(&obj->maxFramebufferLayers, "maxFramebufferLayers", 1); + + print_VkSampleCountFlags(&obj->framebufferColorSampleCounts, "framebufferColorSampleCounts", 1); + + print_VkSampleCountFlags(&obj->framebufferDepthSampleCounts, "framebufferDepthSampleCounts", 1); + + print_VkSampleCountFlags(&obj->framebufferStencilSampleCounts, "framebufferStencilSampleCounts", 1); + + print_VkSampleCountFlags(&obj->framebufferNoAttachmentsSampleCounts, "framebufferNoAttachmentsSampleCounts", 1); + + print_uint32_t(&obj->maxColorAttachments, "maxColorAttachments", 1); + + print_VkSampleCountFlags(&obj->sampledImageColorSampleCounts, "sampledImageColorSampleCounts", 1); + + print_VkSampleCountFlags(&obj->sampledImageIntegerSampleCounts, "sampledImageIntegerSampleCounts", 1); + + print_VkSampleCountFlags(&obj->sampledImageDepthSampleCounts, "sampledImageDepthSampleCounts", 1); + + print_VkSampleCountFlags(&obj->sampledImageStencilSampleCounts, "sampledImageStencilSampleCounts", 1); + + print_VkSampleCountFlags(&obj->storageImageSampleCounts, "storageImageSampleCounts", 1); + + print_uint32_t(&obj->maxSampleMaskWords, "maxSampleMaskWords", 1); + + print_VkBool32(&obj->timestampComputeAndGraphics, "timestampComputeAndGraphics", 1); + + print_float(&obj->timestampPeriod, "timestampPeriod", 1); + + print_uint32_t(&obj->maxClipDistances, "maxClipDistances", 1); + + print_uint32_t(&obj->maxCullDistances, "maxCullDistances", 1); + + print_uint32_t(&obj->maxCombinedClipAndCullDistances, "maxCombinedClipAndCullDistances", 1); + + print_uint32_t(&obj->discreteQueuePriorities, "discreteQueuePriorities", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pointSizeRange\" :"); + if (obj->pointSizeRange) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (2); i++) { + char tmp[100]; + sprintf(tmp, "pointSizeRange_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (2); + print_float(&obj->pointSizeRange[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"lineWidthRange\" :"); + if (obj->lineWidthRange) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (2); i++) { + char tmp[100]; + sprintf(tmp, "lineWidthRange_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (2); + print_float(&obj->lineWidthRange[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_float(&obj->pointSizeGranularity, "pointSizeGranularity", 1); + + print_float(&obj->lineWidthGranularity, "lineWidthGranularity", 1); + + print_VkBool32(&obj->strictLines, "strictLines", 1); + + print_VkBool32(&obj->standardSampleLocations, "standardSampleLocations", 1); + + print_VkDeviceSize(&obj->optimalBufferCopyOffsetAlignment, "optimalBufferCopyOffsetAlignment", 1); + + print_VkDeviceSize(&obj->optimalBufferCopyRowPitchAlignment, "optimalBufferCopyRowPitchAlignment", 1); + + print_VkDeviceSize(&obj->nonCoherentAtomSize, "nonCoherentAtomSize", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkPhysicalDeviceMemoryProperties(const VkPhysicalDeviceMemoryProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint32_t(&obj->memoryTypeCount, "memoryTypeCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"memoryTypes\" :"); + if (obj->memoryTypes) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_MAX_MEMORY_TYPES); i++) { + char tmp[100]; + sprintf(tmp, "memoryTypes_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_MAX_MEMORY_TYPES); + print_VkMemoryType(&obj->memoryTypes[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->memoryHeapCount, "memoryHeapCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"memoryHeaps\" :"); + if (obj->memoryHeaps) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_MAX_MEMORY_HEAPS); i++) { + char tmp[100]; + sprintf(tmp, "memoryHeaps_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_MAX_MEMORY_HEAPS); + print_VkMemoryHeap(&obj->memoryHeaps[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkPhysicalDeviceSparseProperties(const VkPhysicalDeviceSparseProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkBool32(&obj->residencyStandard2DBlockShape, "residencyStandard2DBlockShape", 1); + + print_VkBool32(&obj->residencyStandard2DMultisampleBlockShape, "residencyStandard2DMultisampleBlockShape", 1); + + print_VkBool32(&obj->residencyStandard3DBlockShape, "residencyStandard3DBlockShape", 1); + + print_VkBool32(&obj->residencyAlignedMipSize, "residencyAlignedMipSize", 1); + + print_VkBool32(&obj->residencyNonResidentStrict, "residencyNonResidentStrict", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkPhysicalDeviceProperties(const VkPhysicalDeviceProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint32_t(&obj->apiVersion, "apiVersion", 1); + + print_uint32_t(&obj->driverVersion, "driverVersion", 1); + + print_uint32_t(&obj->vendorID, "vendorID", 1); + + print_uint32_t(&obj->deviceID, "deviceID", 1); + + print_VkPhysicalDeviceType(&obj->deviceType, "deviceType", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"deviceName\" :"); + if (obj->deviceName) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_MAX_PHYSICAL_DEVICE_NAME_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "deviceName_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_MAX_PHYSICAL_DEVICE_NAME_SIZE); + print_char(&obj->deviceName[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pipelineCacheUUID\" :"); + if (obj->pipelineCacheUUID) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_UUID_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "pipelineCacheUUID_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_UUID_SIZE); + print_uint8_t(&obj->pipelineCacheUUID[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"limits\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkPhysicalDeviceLimits(&obj->limits, "limits", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"sparseProperties\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkPhysicalDeviceSparseProperties(&obj->sparseProperties, "sparseProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkQueueFamilyProperties(const VkQueueFamilyProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkQueueFlags(&obj->queueFlags, "queueFlags", 1); + + print_uint32_t(&obj->queueCount, "queueCount", 1); + + print_uint32_t(&obj->timestampValidBits, "timestampValidBits", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"minImageTransferGranularity\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent3D(&obj->minImageTransferGranularity, "minImageTransferGranularity", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDeviceQueueCreateFlags(&obj->flags, "flags", 1); + + print_uint32_t(&obj->queueFamilyIndex, "queueFamilyIndex", 1); + + print_uint32_t(&obj->queueCount, "queueCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pQueuePriorities\" :"); + if (obj->pQueuePriorities) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->queueCount); i++) { + char tmp[100]; + sprintf(tmp, "pQueuePriorities_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->queueCount); + print_float(&obj->pQueuePriorities[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkDeviceCreateInfo(const VkDeviceCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDeviceCreateFlags(&obj->flags, "flags", 1); + + print_uint32_t(&obj->queueCreateInfoCount, "queueCreateInfoCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pQueueCreateInfos\" :"); + if (obj->pQueueCreateInfos) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->queueCreateInfoCount); i++) { + if (i+1 == *(&obj->queueCreateInfoCount)) + print_VkDeviceQueueCreateInfo(&obj->pQueueCreateInfos[i], "pQueueCreateInfos", 0); + else + print_VkDeviceQueueCreateInfo(&obj->pQueueCreateInfos[i], "pQueueCreateInfos", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->enabledLayerCount, "enabledLayerCount", 1); + + /** Printing string inline. **/ + PRINT_SPACE + vk_json_printf(_OUT, "\"ppEnabledLayerNames\" : \"%s\",\n", (char*)obj->ppEnabledLayerNames); + + print_uint32_t(&obj->enabledExtensionCount, "enabledExtensionCount", 1); + + /** Printing string inline. **/ + PRINT_SPACE + vk_json_printf(_OUT, "\"ppEnabledExtensionNames\" : \"%s\",\n", (char*)obj->ppEnabledExtensionNames); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pEnabledFeatures\" :"); + if (obj->pEnabledFeatures) { + vk_json_printf(_OUT, "\n"); + print_VkPhysicalDeviceFeatures(*(&obj->pEnabledFeatures), "pEnabledFeatures", 0); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkExtensionProperties(const VkExtensionProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + PRINT_SPACE + vk_json_printf(_OUT, "\"extensionName\" :"); + if (obj->extensionName) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_MAX_EXTENSION_NAME_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "extensionName_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_MAX_EXTENSION_NAME_SIZE); + print_char(&obj->extensionName[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->specVersion, "specVersion", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkLayerProperties(const VkLayerProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + PRINT_SPACE + vk_json_printf(_OUT, "\"layerName\" :"); + if (obj->layerName) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_MAX_EXTENSION_NAME_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "layerName_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_MAX_EXTENSION_NAME_SIZE); + print_char(&obj->layerName[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->specVersion, "specVersion", 1); + + print_uint32_t(&obj->implementationVersion, "implementationVersion", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"description\" :"); + if (obj->description) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_MAX_DESCRIPTION_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "description_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_MAX_DESCRIPTION_SIZE); + print_char(&obj->description[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkSubmitInfo(const VkSubmitInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->waitSemaphoreCount, "waitSemaphoreCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pWaitSemaphores\" :"); + if (obj->pWaitSemaphores) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->waitSemaphoreCount); i++) { + char tmp[100]; + sprintf(tmp, "pWaitSemaphores_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->waitSemaphoreCount); + print_VkSemaphore(&obj->pWaitSemaphores[i], tmp, isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pWaitDstStageMask\" :"); + if (obj->pWaitDstStageMask) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->waitSemaphoreCount); i++) { + char tmp[100]; + sprintf(tmp, "pWaitDstStageMask_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->waitSemaphoreCount); + print_VkPipelineStageFlags(&obj->pWaitDstStageMask[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->commandBufferCount, "commandBufferCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pCommandBuffers\" :"); + if (obj->pCommandBuffers) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->commandBufferCount); i++) { + char tmp[100]; + sprintf(tmp, "pCommandBuffers_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->commandBufferCount); + print_VkCommandBuffer(&obj->pCommandBuffers[i], tmp, isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->signalSemaphoreCount, "signalSemaphoreCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pSignalSemaphores\" :"); + if (obj->pSignalSemaphores) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->signalSemaphoreCount); i++) { + char tmp[100]; + sprintf(tmp, "pSignalSemaphores_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->signalSemaphoreCount); + print_VkSemaphore(&obj->pSignalSemaphores[i], tmp, isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkMappedMemoryRange(const VkMappedMemoryRange * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"memory\" : \"\",\n"); + + print_VkDeviceSize(&obj->offset, "offset", 1); + + print_VkDeviceSize(&obj->size, "size", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkMemoryAllocateInfo(const VkMemoryAllocateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDeviceSize(&obj->allocationSize, "allocationSize", 1); + + print_uint32_t(&obj->memoryTypeIndex, "memoryTypeIndex", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkMemoryRequirements(const VkMemoryRequirements * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkDeviceSize(&obj->size, "size", 1); + + print_VkDeviceSize(&obj->alignment, "alignment", 1); + + print_uint32_t(&obj->memoryTypeBits, "memoryTypeBits", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkImageSubresource(const VkImageSubresource * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkImageAspectFlags(&obj->aspectMask, "aspectMask", 1); + + print_uint32_t(&obj->mipLevel, "mipLevel", 1); + + print_uint32_t(&obj->arrayLayer, "arrayLayer", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkFenceCreateInfo(const VkFenceCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkFenceCreateFlags(&obj->flags, "flags", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkSemaphoreCreateFlags(&obj->flags, "flags", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkEventCreateInfo(const VkEventCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkEventCreateFlags(&obj->flags, "flags", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkQueryPoolCreateFlags(&obj->flags, "flags", 1); + + print_VkQueryType(&obj->queryType, "queryType", 1); + + print_uint32_t(&obj->queryCount, "queryCount", 1); + + print_VkQueryPipelineStatisticFlags(&obj->pipelineStatistics, "pipelineStatistics", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkBufferCreateInfo(const VkBufferCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBufferCreateFlags(&obj->flags, "flags", 1); + + print_VkDeviceSize(&obj->size, "size", 1); + + print_VkBufferUsageFlags(&obj->usage, "usage", 1); + + print_VkSharingMode(&obj->sharingMode, "sharingMode", 1); + + print_uint32_t(&obj->queueFamilyIndexCount, "queueFamilyIndexCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pQueueFamilyIndices\" :"); + if (obj->pQueueFamilyIndices) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->queueFamilyIndexCount); i++) { + char tmp[100]; + sprintf(tmp, "pQueueFamilyIndices_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->queueFamilyIndexCount); + print_uint32_t(&obj->pQueueFamilyIndices[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkBufferViewCreateInfo(const VkBufferViewCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBufferViewCreateFlags(&obj->flags, "flags", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"buffer\" : \"\",\n"); + + print_VkFormat(&obj->format, "format", 1); + + print_VkDeviceSize(&obj->offset, "offset", 1); + + print_VkDeviceSize(&obj->range, "range", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkImageCreateInfo(const VkImageCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkImageCreateFlags(&obj->flags, "flags", 1); + + print_VkImageType(&obj->imageType, "imageType", 1); + + print_VkFormat(&obj->format, "format", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"extent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent3D(&obj->extent, "extent", 1); + } + + print_uint32_t(&obj->mipLevels, "mipLevels", 1); + + print_uint32_t(&obj->arrayLayers, "arrayLayers", 1); + + print_VkSampleCountFlagBits(&obj->samples, "samples", 1); + + print_VkImageTiling(&obj->tiling, "tiling", 1); + + print_VkImageUsageFlags(&obj->usage, "usage", 1); + + print_VkSharingMode(&obj->sharingMode, "sharingMode", 1); + + print_uint32_t(&obj->queueFamilyIndexCount, "queueFamilyIndexCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pQueueFamilyIndices\" :"); + if (obj->pQueueFamilyIndices) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->queueFamilyIndexCount); i++) { + char tmp[100]; + sprintf(tmp, "pQueueFamilyIndices_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->queueFamilyIndexCount); + print_uint32_t(&obj->pQueueFamilyIndices[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_VkImageLayout(&obj->initialLayout, "initialLayout", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkSubresourceLayout(const VkSubresourceLayout * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkDeviceSize(&obj->offset, "offset", 1); + + print_VkDeviceSize(&obj->size, "size", 1); + + print_VkDeviceSize(&obj->rowPitch, "rowPitch", 1); + + print_VkDeviceSize(&obj->arrayPitch, "arrayPitch", 1); + + print_VkDeviceSize(&obj->depthPitch, "depthPitch", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkComponentMapping(const VkComponentMapping * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkComponentSwizzle(&obj->r, "r", 1); + + print_VkComponentSwizzle(&obj->g, "g", 1); + + print_VkComponentSwizzle(&obj->b, "b", 1); + + print_VkComponentSwizzle(&obj->a, "a", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkImageViewCreateInfo(const VkImageViewCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkImageViewCreateFlags(&obj->flags, "flags", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"image\" : \"\",\n"); + + print_VkImageViewType(&obj->viewType, "viewType", 1); + + print_VkFormat(&obj->format, "format", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"components\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkComponentMapping(&obj->components, "components", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"subresourceRange\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkImageSubresourceRange(&obj->subresourceRange, "subresourceRange", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineCacheCreateFlags(&obj->flags, "flags", 1); + + print_size_t(&obj->initialDataSize, "initialDataSize", 1); + + /** Note: Ignoring void* data. **/ + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkSpecializationMapEntry(const VkSpecializationMapEntry * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint32_t(&obj->constantID, "constantID", 1); + + print_uint32_t(&obj->offset, "offset", 1); + + print_size_t(&obj->size, "size", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkSpecializationInfo(const VkSpecializationInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint32_t(&obj->mapEntryCount, "mapEntryCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pMapEntries\" :"); + if (obj->pMapEntries) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->mapEntryCount); i++) { + if (i+1 == *(&obj->mapEntryCount)) + print_VkSpecializationMapEntry(&obj->pMapEntries[i], "pMapEntries", 0); + else + print_VkSpecializationMapEntry(&obj->pMapEntries[i], "pMapEntries", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_size_t(&obj->dataSize, "dataSize", 1); + + /** Note: Ignoring void* data. **/ + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineShaderStageCreateFlags(&obj->flags, "flags", 1); + + print_VkShaderStageFlagBits(&obj->stage, "stage", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"module\" : \"\",\n"); + + /** Printing string inline. **/ + PRINT_SPACE + vk_json_printf(_OUT, "\"pName\" : \"%s\",\n", (char*)obj->pName); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pSpecializationInfo\" :"); + if (obj->pSpecializationInfo) { + vk_json_printf(_OUT, "\n"); + print_VkSpecializationInfo(*(&obj->pSpecializationInfo), "pSpecializationInfo", 0); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineCreateFlags(&obj->flags, "flags", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"stage\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkPipelineShaderStageCreateInfo(&obj->stage, "stage", 1); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"layout\" : \"\",\n"); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"basePipelineHandle\" : \"\",\n"); + + print_int32_t(&obj->basePipelineIndex, "basePipelineIndex", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkVertexInputBindingDescription(const VkVertexInputBindingDescription * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint32_t(&obj->binding, "binding", 1); + + print_uint32_t(&obj->stride, "stride", 1); + + print_VkVertexInputRate(&obj->inputRate, "inputRate", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkVertexInputAttributeDescription(const VkVertexInputAttributeDescription * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint32_t(&obj->location, "location", 1); + + print_uint32_t(&obj->binding, "binding", 1); + + print_VkFormat(&obj->format, "format", 1); + + print_uint32_t(&obj->offset, "offset", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineVertexInputStateCreateFlags(&obj->flags, "flags", 1); + + print_uint32_t(&obj->vertexBindingDescriptionCount, "vertexBindingDescriptionCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pVertexBindingDescriptions\" :"); + if (obj->pVertexBindingDescriptions) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->vertexBindingDescriptionCount); i++) { + if (i+1 == *(&obj->vertexBindingDescriptionCount)) + print_VkVertexInputBindingDescription(&obj->pVertexBindingDescriptions[i], "pVertexBindingDescriptions", 0); + else + print_VkVertexInputBindingDescription(&obj->pVertexBindingDescriptions[i], "pVertexBindingDescriptions", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->vertexAttributeDescriptionCount, "vertexAttributeDescriptionCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pVertexAttributeDescriptions\" :"); + if (obj->pVertexAttributeDescriptions) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->vertexAttributeDescriptionCount); i++) { + if (i+1 == *(&obj->vertexAttributeDescriptionCount)) + print_VkVertexInputAttributeDescription(&obj->pVertexAttributeDescriptions[i], "pVertexAttributeDescriptions", 0); + else + print_VkVertexInputAttributeDescription(&obj->pVertexAttributeDescriptions[i], "pVertexAttributeDescriptions", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineInputAssemblyStateCreateFlags(&obj->flags, "flags", 1); + + print_VkPrimitiveTopology(&obj->topology, "topology", 1); + + print_VkBool32(&obj->primitiveRestartEnable, "primitiveRestartEnable", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineTessellationStateCreateFlags(&obj->flags, "flags", 1); + + print_uint32_t(&obj->patchControlPoints, "patchControlPoints", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkViewport(const VkViewport * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_float(&obj->x, "x", 1); + + print_float(&obj->y, "y", 1); + + print_float(&obj->width, "width", 1); + + print_float(&obj->height, "height", 1); + + print_float(&obj->minDepth, "minDepth", 1); + + print_float(&obj->maxDepth, "maxDepth", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineViewportStateCreateFlags(&obj->flags, "flags", 1); + + print_uint32_t(&obj->viewportCount, "viewportCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pViewports\" :"); + if (obj->pViewports) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->viewportCount); i++) { + if (i+1 == *(&obj->viewportCount)) + print_VkViewport(&obj->pViewports[i], "pViewports", 0); + else + print_VkViewport(&obj->pViewports[i], "pViewports", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->scissorCount, "scissorCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pScissors\" :"); + if (obj->pScissors) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->scissorCount); i++) { + if (i+1 == *(&obj->scissorCount)) + print_VkRect2D(&obj->pScissors[i], "pScissors", 0); + else + print_VkRect2D(&obj->pScissors[i], "pScissors", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineRasterizationStateCreateFlags(&obj->flags, "flags", 1); + + print_VkBool32(&obj->depthClampEnable, "depthClampEnable", 1); + + print_VkBool32(&obj->rasterizerDiscardEnable, "rasterizerDiscardEnable", 1); + + print_VkPolygonMode(&obj->polygonMode, "polygonMode", 1); + + print_VkCullModeFlags(&obj->cullMode, "cullMode", 1); + + print_VkFrontFace(&obj->frontFace, "frontFace", 1); + + print_VkBool32(&obj->depthBiasEnable, "depthBiasEnable", 1); + + print_float(&obj->depthBiasConstantFactor, "depthBiasConstantFactor", 1); + + print_float(&obj->depthBiasClamp, "depthBiasClamp", 1); + + print_float(&obj->depthBiasSlopeFactor, "depthBiasSlopeFactor", 1); + + print_float(&obj->lineWidth, "lineWidth", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineMultisampleStateCreateFlags(&obj->flags, "flags", 1); + + print_VkSampleCountFlagBits(&obj->rasterizationSamples, "rasterizationSamples", 1); + + print_VkBool32(&obj->sampleShadingEnable, "sampleShadingEnable", 1); + + print_float(&obj->minSampleShading, "minSampleShading", 1); + + /** Skipping VkSampleMask. **/ + + print_VkBool32(&obj->alphaToCoverageEnable, "alphaToCoverageEnable", 1); + + print_VkBool32(&obj->alphaToOneEnable, "alphaToOneEnable", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkStencilOpState(const VkStencilOpState * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStencilOp(&obj->failOp, "failOp", 1); + + print_VkStencilOp(&obj->passOp, "passOp", 1); + + print_VkStencilOp(&obj->depthFailOp, "depthFailOp", 1); + + print_VkCompareOp(&obj->compareOp, "compareOp", 1); + + print_uint32_t(&obj->compareMask, "compareMask", 1); + + print_uint32_t(&obj->writeMask, "writeMask", 1); + + print_uint32_t(&obj->reference, "reference", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineDepthStencilStateCreateFlags(&obj->flags, "flags", 1); + + print_VkBool32(&obj->depthTestEnable, "depthTestEnable", 1); + + print_VkBool32(&obj->depthWriteEnable, "depthWriteEnable", 1); + + print_VkCompareOp(&obj->depthCompareOp, "depthCompareOp", 1); + + print_VkBool32(&obj->depthBoundsTestEnable, "depthBoundsTestEnable", 1); + + print_VkBool32(&obj->stencilTestEnable, "stencilTestEnable", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"front\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkStencilOpState(&obj->front, "front", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"back\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkStencilOpState(&obj->back, "back", 1); + } + + print_float(&obj->minDepthBounds, "minDepthBounds", 1); + + print_float(&obj->maxDepthBounds, "maxDepthBounds", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkPipelineColorBlendAttachmentState(const VkPipelineColorBlendAttachmentState * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkBool32(&obj->blendEnable, "blendEnable", 1); + + print_VkBlendFactor(&obj->srcColorBlendFactor, "srcColorBlendFactor", 1); + + print_VkBlendFactor(&obj->dstColorBlendFactor, "dstColorBlendFactor", 1); + + print_VkBlendOp(&obj->colorBlendOp, "colorBlendOp", 1); + + print_VkBlendFactor(&obj->srcAlphaBlendFactor, "srcAlphaBlendFactor", 1); + + print_VkBlendFactor(&obj->dstAlphaBlendFactor, "dstAlphaBlendFactor", 1); + + print_VkBlendOp(&obj->alphaBlendOp, "alphaBlendOp", 1); + + print_VkColorComponentFlags(&obj->colorWriteMask, "colorWriteMask", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineColorBlendStateCreateFlags(&obj->flags, "flags", 1); + + print_VkBool32(&obj->logicOpEnable, "logicOpEnable", 1); + + print_VkLogicOp(&obj->logicOp, "logicOp", 1); + + print_uint32_t(&obj->attachmentCount, "attachmentCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pAttachments\" :"); + if (obj->pAttachments) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->attachmentCount); i++) { + if (i+1 == *(&obj->attachmentCount)) + print_VkPipelineColorBlendAttachmentState(&obj->pAttachments[i], "pAttachments", 0); + else + print_VkPipelineColorBlendAttachmentState(&obj->pAttachments[i], "pAttachments", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"blendConstants\" :"); + if (obj->blendConstants) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (4); i++) { + char tmp[100]; + sprintf(tmp, "blendConstants_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (4); + print_float(&obj->blendConstants[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineDynamicStateCreateFlags(&obj->flags, "flags", 1); + + print_uint32_t(&obj->dynamicStateCount, "dynamicStateCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pDynamicStates\" :"); + if (obj->pDynamicStates) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->dynamicStateCount); i++) { + char tmp[100]; + sprintf(tmp, "pDynamicStates_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->dynamicStateCount); + print_VkDynamicState(&obj->pDynamicStates[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineCreateFlags(&obj->flags, "flags", 1); + + print_uint32_t(&obj->stageCount, "stageCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pStages\" :"); + if (obj->pStages) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->stageCount); i++) { + if (i+1 == *(&obj->stageCount)) + print_VkPipelineShaderStageCreateInfo(&obj->pStages[i], "pStages", 0); + else + print_VkPipelineShaderStageCreateInfo(&obj->pStages[i], "pStages", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pVertexInputState\" :"); + if (obj->pVertexInputState) { + vk_json_printf(_OUT, "\n"); + print_VkPipelineVertexInputStateCreateInfo(*(&obj->pVertexInputState), "pVertexInputState", 1); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pInputAssemblyState\" :"); + if (obj->pInputAssemblyState) { + vk_json_printf(_OUT, "\n"); + print_VkPipelineInputAssemblyStateCreateInfo(*(&obj->pInputAssemblyState), "pInputAssemblyState", 1); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pTessellationState\" :"); + if (obj->pTessellationState) { + vk_json_printf(_OUT, "\n"); + print_VkPipelineTessellationStateCreateInfo(*(&obj->pTessellationState), "pTessellationState", 1); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pViewportState\" :"); + if (obj->pViewportState) { + vk_json_printf(_OUT, "\n"); + print_VkPipelineViewportStateCreateInfo(*(&obj->pViewportState), "pViewportState", 1); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pRasterizationState\" :"); + if (obj->pRasterizationState) { + vk_json_printf(_OUT, "\n"); + print_VkPipelineRasterizationStateCreateInfo(*(&obj->pRasterizationState), "pRasterizationState", 1); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pMultisampleState\" :"); + if (obj->pMultisampleState) { + vk_json_printf(_OUT, "\n"); + print_VkPipelineMultisampleStateCreateInfo(*(&obj->pMultisampleState), "pMultisampleState", 1); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pDepthStencilState\" :"); + if (obj->pDepthStencilState) { + vk_json_printf(_OUT, "\n"); + print_VkPipelineDepthStencilStateCreateInfo(*(&obj->pDepthStencilState), "pDepthStencilState", 1); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pColorBlendState\" :"); + if (obj->pColorBlendState) { + vk_json_printf(_OUT, "\n"); + print_VkPipelineColorBlendStateCreateInfo(*(&obj->pColorBlendState), "pColorBlendState", 1); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pDynamicState\" :"); + if (obj->pDynamicState) { + vk_json_printf(_OUT, "\n"); + print_VkPipelineDynamicStateCreateInfo(*(&obj->pDynamicState), "pDynamicState", 1); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"layout\" : \"\",\n"); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"renderPass\" : \"\",\n"); + + print_uint32_t(&obj->subpass, "subpass", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"basePipelineHandle\" : \"\",\n"); + + print_int32_t(&obj->basePipelineIndex, "basePipelineIndex", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkPushConstantRange(const VkPushConstantRange * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkShaderStageFlags(&obj->stageFlags, "stageFlags", 1); + + print_uint32_t(&obj->offset, "offset", 1); + + print_uint32_t(&obj->size, "size", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineLayoutCreateFlags(&obj->flags, "flags", 1); + + print_uint32_t(&obj->setLayoutCount, "setLayoutCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pSetLayouts\" :"); + if (obj->pSetLayouts) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->setLayoutCount); i++) { + char tmp[100]; + sprintf(tmp, "pSetLayouts_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->setLayoutCount); + print_VkDescriptorSetLayout(&obj->pSetLayouts[i], tmp, isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->pushConstantRangeCount, "pushConstantRangeCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pPushConstantRanges\" :"); + if (obj->pPushConstantRanges) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->pushConstantRangeCount); i++) { + if (i+1 == *(&obj->pushConstantRangeCount)) + print_VkPushConstantRange(&obj->pPushConstantRanges[i], "pPushConstantRanges", 0); + else + print_VkPushConstantRange(&obj->pPushConstantRanges[i], "pPushConstantRanges", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkSamplerCreateInfo(const VkSamplerCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkSamplerCreateFlags(&obj->flags, "flags", 1); + + print_VkFilter(&obj->magFilter, "magFilter", 1); + + print_VkFilter(&obj->minFilter, "minFilter", 1); + + print_VkSamplerMipmapMode(&obj->mipmapMode, "mipmapMode", 1); + + print_VkSamplerAddressMode(&obj->addressModeU, "addressModeU", 1); + + print_VkSamplerAddressMode(&obj->addressModeV, "addressModeV", 1); + + print_VkSamplerAddressMode(&obj->addressModeW, "addressModeW", 1); + + print_float(&obj->mipLodBias, "mipLodBias", 1); + + print_VkBool32(&obj->anisotropyEnable, "anisotropyEnable", 1); + + print_float(&obj->maxAnisotropy, "maxAnisotropy", 1); + + print_VkBool32(&obj->compareEnable, "compareEnable", 1); + + print_VkCompareOp(&obj->compareOp, "compareOp", 1); + + print_float(&obj->minLod, "minLod", 1); + + print_float(&obj->maxLod, "maxLod", 1); + + print_VkBorderColor(&obj->borderColor, "borderColor", 1); + + print_VkBool32(&obj->unnormalizedCoordinates, "unnormalizedCoordinates", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkCopyDescriptorSet(const VkCopyDescriptorSet * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"srcSet\" : \"\",\n"); + + print_uint32_t(&obj->srcBinding, "srcBinding", 1); + + print_uint32_t(&obj->srcArrayElement, "srcArrayElement", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"dstSet\" : \"\",\n"); + + print_uint32_t(&obj->dstBinding, "dstBinding", 1); + + print_uint32_t(&obj->dstArrayElement, "dstArrayElement", 1); + + print_uint32_t(&obj->descriptorCount, "descriptorCount", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkDescriptorBufferInfo(const VkDescriptorBufferInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"buffer\" : \"\",\n"); + + print_VkDeviceSize(&obj->offset, "offset", 1); + + print_VkDeviceSize(&obj->range, "range", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkDescriptorImageInfo(const VkDescriptorImageInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"sampler\" : \"\",\n"); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"imageView\" : \"\",\n"); + + print_VkImageLayout(&obj->imageLayout, "imageLayout", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkDescriptorPoolSize(const VkDescriptorPoolSize * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkDescriptorType(&obj->type, "type", 1); + + print_uint32_t(&obj->descriptorCount, "descriptorCount", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDescriptorPoolCreateFlags(&obj->flags, "flags", 1); + + print_uint32_t(&obj->maxSets, "maxSets", 1); + + print_uint32_t(&obj->poolSizeCount, "poolSizeCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pPoolSizes\" :"); + if (obj->pPoolSizes) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->poolSizeCount); i++) { + if (i+1 == *(&obj->poolSizeCount)) + print_VkDescriptorPoolSize(&obj->pPoolSizes[i], "pPoolSizes", 0); + else + print_VkDescriptorPoolSize(&obj->pPoolSizes[i], "pPoolSizes", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"descriptorPool\" : \"\",\n"); + + print_uint32_t(&obj->descriptorSetCount, "descriptorSetCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pSetLayouts\" :"); + if (obj->pSetLayouts) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->descriptorSetCount); i++) { + char tmp[100]; + sprintf(tmp, "pSetLayouts_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->descriptorSetCount); + print_VkDescriptorSetLayout(&obj->pSetLayouts[i], tmp, isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint32_t(&obj->binding, "binding", 1); + + print_VkDescriptorType(&obj->descriptorType, "descriptorType", 1); + + print_uint32_t(&obj->descriptorCount, "descriptorCount", 1); + + print_VkShaderStageFlags(&obj->stageFlags, "stageFlags", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pImmutableSamplers\" :"); + if (obj->pImmutableSamplers) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->descriptorCount); i++) { + char tmp[100]; + sprintf(tmp, "pImmutableSamplers_%u_%u", *(&obj->binding), i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->descriptorCount); + print_VkSampler(&obj->pImmutableSamplers[i], tmp, isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDescriptorSetLayoutCreateFlags(&obj->flags, "flags", 1); + + print_uint32_t(&obj->bindingCount, "bindingCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pBindings\" :"); + if (obj->pBindings) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->bindingCount); i++) { + if (i+1 == *(&obj->bindingCount)) + print_VkDescriptorSetLayoutBinding(&obj->pBindings[i], "pBindings", 0); + else + print_VkDescriptorSetLayoutBinding(&obj->pBindings[i], "pBindings", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkWriteDescriptorSet(const VkWriteDescriptorSet * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"dstSet\" : \"\",\n"); + + print_uint32_t(&obj->dstBinding, "dstBinding", 1); + + print_uint32_t(&obj->dstArrayElement, "dstArrayElement", 1); + + print_uint32_t(&obj->descriptorCount, "descriptorCount", 1); + + print_VkDescriptorType(&obj->descriptorType, "descriptorType", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pImageInfo\" :"); + if (obj->pImageInfo) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->descriptorCount); i++) { + if (i+1 == *(&obj->descriptorCount)) + print_VkDescriptorImageInfo(&obj->pImageInfo[i], "pImageInfo", 0); + else + print_VkDescriptorImageInfo(&obj->pImageInfo[i], "pImageInfo", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pBufferInfo\" :"); + if (obj->pBufferInfo) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->descriptorCount); i++) { + if (i+1 == *(&obj->descriptorCount)) + print_VkDescriptorBufferInfo(&obj->pBufferInfo[i], "pBufferInfo", 0); + else + print_VkDescriptorBufferInfo(&obj->pBufferInfo[i], "pBufferInfo", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pTexelBufferView\" :"); + if (obj->pTexelBufferView) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->descriptorCount); i++) { + char tmp[100]; + sprintf(tmp, "pTexelBufferView_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->descriptorCount); + print_VkBufferView(&obj->pTexelBufferView[i], tmp, isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkAttachmentDescription(const VkAttachmentDescription * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkAttachmentDescriptionFlags(&obj->flags, "flags", 1); + + print_VkFormat(&obj->format, "format", 1); + + print_VkSampleCountFlagBits(&obj->samples, "samples", 1); + + print_VkAttachmentLoadOp(&obj->loadOp, "loadOp", 1); + + print_VkAttachmentStoreOp(&obj->storeOp, "storeOp", 1); + + print_VkAttachmentLoadOp(&obj->stencilLoadOp, "stencilLoadOp", 1); + + print_VkAttachmentStoreOp(&obj->stencilStoreOp, "stencilStoreOp", 1); + + print_VkImageLayout(&obj->initialLayout, "initialLayout", 1); + + print_VkImageLayout(&obj->finalLayout, "finalLayout", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkAttachmentReference(const VkAttachmentReference * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint32_t(&obj->attachment, "attachment", 1); + + print_VkImageLayout(&obj->layout, "layout", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkFramebufferCreateInfo(const VkFramebufferCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkFramebufferCreateFlags(&obj->flags, "flags", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"renderPass\" : \"\",\n"); + + print_uint32_t(&obj->attachmentCount, "attachmentCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pAttachments\" :"); + if (obj->pAttachments) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->attachmentCount); i++) { + char tmp[100]; + sprintf(tmp, "pAttachments_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->attachmentCount); + print_VkImageView(&obj->pAttachments[i], tmp, isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->width, "width", 1); + + print_uint32_t(&obj->height, "height", 1); + + print_uint32_t(&obj->layers, "layers", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkSubpassDescription(const VkSubpassDescription * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkSubpassDescriptionFlags(&obj->flags, "flags", 1); + + print_VkPipelineBindPoint(&obj->pipelineBindPoint, "pipelineBindPoint", 1); + + print_uint32_t(&obj->inputAttachmentCount, "inputAttachmentCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pInputAttachments\" :"); + if (obj->pInputAttachments) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->inputAttachmentCount); i++) { + if (i+1 == *(&obj->inputAttachmentCount)) + print_VkAttachmentReference(&obj->pInputAttachments[i], "pInputAttachments", 0); + else + print_VkAttachmentReference(&obj->pInputAttachments[i], "pInputAttachments", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->colorAttachmentCount, "colorAttachmentCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pColorAttachments\" :"); + if (obj->pColorAttachments) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->colorAttachmentCount); i++) { + if (i+1 == *(&obj->colorAttachmentCount)) + print_VkAttachmentReference(&obj->pColorAttachments[i], "pColorAttachments", 0); + else + print_VkAttachmentReference(&obj->pColorAttachments[i], "pColorAttachments", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pResolveAttachments\" :"); + if (obj->pResolveAttachments) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->colorAttachmentCount); i++) { + if (i+1 == *(&obj->colorAttachmentCount)) + print_VkAttachmentReference(&obj->pResolveAttachments[i], "pResolveAttachments", 0); + else + print_VkAttachmentReference(&obj->pResolveAttachments[i], "pResolveAttachments", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pDepthStencilAttachment\" :"); + if (obj->pDepthStencilAttachment) { + vk_json_printf(_OUT, "\n"); + print_VkAttachmentReference(*(&obj->pDepthStencilAttachment), "pDepthStencilAttachment", 1); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->preserveAttachmentCount, "preserveAttachmentCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pPreserveAttachments\" :"); + if (obj->pPreserveAttachments) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->preserveAttachmentCount); i++) { + char tmp[100]; + sprintf(tmp, "pPreserveAttachments_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->preserveAttachmentCount); + print_uint32_t(&obj->pPreserveAttachments[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkSubpassDependency(const VkSubpassDependency * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint32_t(&obj->srcSubpass, "srcSubpass", 1); + + print_uint32_t(&obj->dstSubpass, "dstSubpass", 1); + + print_VkPipelineStageFlags(&obj->srcStageMask, "srcStageMask", 1); + + print_VkPipelineStageFlags(&obj->dstStageMask, "dstStageMask", 1); + + print_VkAccessFlags(&obj->srcAccessMask, "srcAccessMask", 1); + + print_VkAccessFlags(&obj->dstAccessMask, "dstAccessMask", 1); + + print_VkDependencyFlags(&obj->dependencyFlags, "dependencyFlags", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkRenderPassCreateInfo(const VkRenderPassCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkRenderPassCreateFlags(&obj->flags, "flags", 1); + + print_uint32_t(&obj->attachmentCount, "attachmentCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pAttachments\" :"); + if (obj->pAttachments) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->attachmentCount); i++) { + if (i+1 == *(&obj->attachmentCount)) + print_VkAttachmentDescription(&obj->pAttachments[i], "pAttachments", 0); + else + print_VkAttachmentDescription(&obj->pAttachments[i], "pAttachments", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->subpassCount, "subpassCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pSubpasses\" :"); + if (obj->pSubpasses) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->subpassCount); i++) { + if (i+1 == *(&obj->subpassCount)) + print_VkSubpassDescription(&obj->pSubpasses[i], "pSubpasses", 0); + else + print_VkSubpassDescription(&obj->pSubpasses[i], "pSubpasses", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->dependencyCount, "dependencyCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pDependencies\" :"); + if (obj->pDependencies) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->dependencyCount); i++) { + if (i+1 == *(&obj->dependencyCount)) + print_VkSubpassDependency(&obj->pDependencies[i], "pDependencies", 0); + else + print_VkSubpassDependency(&obj->pDependencies[i], "pDependencies", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkCommandPoolCreateFlags(&obj->flags, "flags", 1); + + print_uint32_t(&obj->queueFamilyIndex, "queueFamilyIndex", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"commandPool\" : \"\",\n"); + + print_VkCommandBufferLevel(&obj->level, "level", 1); + + print_uint32_t(&obj->commandBufferCount, "commandBufferCount", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"renderPass\" : \"\",\n"); + + print_uint32_t(&obj->subpass, "subpass", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"framebuffer\" : \"\",\n"); + + print_VkBool32(&obj->occlusionQueryEnable, "occlusionQueryEnable", 1); + + print_VkQueryControlFlags(&obj->queryFlags, "queryFlags", 1); + + print_VkQueryPipelineStatisticFlags(&obj->pipelineStatistics, "pipelineStatistics", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkCommandBufferUsageFlags(&obj->flags, "flags", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pInheritanceInfo\" :"); + if (obj->pInheritanceInfo) { + vk_json_printf(_OUT, "\n"); + print_VkCommandBufferInheritanceInfo(*(&obj->pInheritanceInfo), "pInheritanceInfo", 0); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkBufferCopy(const VkBufferCopy * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkDeviceSize(&obj->srcOffset, "srcOffset", 1); + + print_VkDeviceSize(&obj->dstOffset, "dstOffset", 1); + + print_VkDeviceSize(&obj->size, "size", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkImageSubresourceLayers(const VkImageSubresourceLayers * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkImageAspectFlags(&obj->aspectMask, "aspectMask", 1); + + print_uint32_t(&obj->mipLevel, "mipLevel", 1); + + print_uint32_t(&obj->baseArrayLayer, "baseArrayLayer", 1); + + print_uint32_t(&obj->layerCount, "layerCount", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkBufferImageCopy(const VkBufferImageCopy * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkDeviceSize(&obj->bufferOffset, "bufferOffset", 1); + + print_uint32_t(&obj->bufferRowLength, "bufferRowLength", 1); + + print_uint32_t(&obj->bufferImageHeight, "bufferImageHeight", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"imageSubresource\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkImageSubresourceLayers(&obj->imageSubresource, "imageSubresource", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"imageOffset\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkOffset3D(&obj->imageOffset, "imageOffset", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"imageExtent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent3D(&obj->imageExtent, "imageExtent", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkClearColorValue(const VkClearColorValue * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + PRINT_SPACE + vk_json_printf(_OUT, "\"float32\" :"); + if (obj->float32) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (4); i++) { + char tmp[100]; + sprintf(tmp, "float32_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (4); + print_float(&obj->float32[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"int32\" :"); + if (obj->int32) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (4); i++) { + char tmp[100]; + sprintf(tmp, "int32_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (4); + print_int32_t(&obj->int32[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"uint32\" :"); + if (obj->uint32) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (4); i++) { + char tmp[100]; + sprintf(tmp, "uint32_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (4); + print_uint32_t(&obj->uint32[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkClearDepthStencilValue(const VkClearDepthStencilValue * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_float(&obj->depth, "depth", 1); + + print_uint32_t(&obj->stencil, "stencil", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkClearValue(const VkClearValue * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkClearColorValue(&obj->color, "color", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"depthStencil\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkClearDepthStencilValue(&obj->depthStencil, "depthStencil", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkClearAttachment(const VkClearAttachment * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkImageAspectFlags(&obj->aspectMask, "aspectMask", 1); + + print_uint32_t(&obj->colorAttachment, "colorAttachment", 1); + + print_VkClearValue(&obj->clearValue, "clearValue", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkClearRect(const VkClearRect * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + PRINT_SPACE + vk_json_printf(_OUT, "\"rect\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkRect2D(&obj->rect, "rect", 1); + } + + print_uint32_t(&obj->baseArrayLayer, "baseArrayLayer", 1); + + print_uint32_t(&obj->layerCount, "layerCount", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkImageBlit(const VkImageBlit * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + PRINT_SPACE + vk_json_printf(_OUT, "\"srcSubresource\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkImageSubresourceLayers(&obj->srcSubresource, "srcSubresource", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"srcOffsets\" :"); + if (obj->srcOffsets) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (2); i++) { + char tmp[100]; + sprintf(tmp, "srcOffsets_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (2); + print_VkOffset3D(&obj->srcOffsets[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"dstSubresource\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkImageSubresourceLayers(&obj->dstSubresource, "dstSubresource", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"dstOffsets\" :"); + if (obj->dstOffsets) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (2); i++) { + char tmp[100]; + sprintf(tmp, "dstOffsets_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (2); + print_VkOffset3D(&obj->dstOffsets[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkImageCopy(const VkImageCopy * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + PRINT_SPACE + vk_json_printf(_OUT, "\"srcSubresource\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkImageSubresourceLayers(&obj->srcSubresource, "srcSubresource", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"srcOffset\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkOffset3D(&obj->srcOffset, "srcOffset", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"dstSubresource\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkImageSubresourceLayers(&obj->dstSubresource, "dstSubresource", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"dstOffset\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkOffset3D(&obj->dstOffset, "dstOffset", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"extent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent3D(&obj->extent, "extent", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkImageResolve(const VkImageResolve * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + PRINT_SPACE + vk_json_printf(_OUT, "\"srcSubresource\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkImageSubresourceLayers(&obj->srcSubresource, "srcSubresource", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"srcOffset\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkOffset3D(&obj->srcOffset, "srcOffset", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"dstSubresource\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkImageSubresourceLayers(&obj->dstSubresource, "dstSubresource", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"dstOffset\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkOffset3D(&obj->dstOffset, "dstOffset", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"extent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent3D(&obj->extent, "extent", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +void print_VkRenderPassBeginInfo(const VkRenderPassBeginInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"renderPass\" : \"\",\n"); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"framebuffer\" : \"\",\n"); + + PRINT_SPACE + vk_json_printf(_OUT, "\"renderArea\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkRect2D(&obj->renderArea, "renderArea", 1); + } + + print_uint32_t(&obj->clearValueCount, "clearValueCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pClearValues\" :"); + if (obj->pClearValues) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->clearValueCount); i++) { + char tmp[100]; + sprintf(tmp, "pClearValues_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->clearValueCount); + print_VkClearValue(&obj->pClearValues[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#ifdef VK_VERSION_1_1 +void print_VkSamplerYcbcrConversion(const VkSamplerYcbcrConversion * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +static const char* VkSubgroupFeatureFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_SUBGROUP_FEATURE_BASIC_BIT"; + case (1 << 1): return "VK_SUBGROUP_FEATURE_VOTE_BIT"; + case (1 << 2): return "VK_SUBGROUP_FEATURE_ARITHMETIC_BIT"; + case (1 << 3): return "VK_SUBGROUP_FEATURE_BALLOT_BIT"; + case (1 << 4): return "VK_SUBGROUP_FEATURE_SHUFFLE_BIT"; + case (1 << 5): return "VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT"; + case (1 << 6): return "VK_SUBGROUP_FEATURE_CLUSTERED_BIT"; + case (1 << 7): return "VK_SUBGROUP_FEATURE_QUAD_BIT"; + case (1 << 8): return "VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV"; + } + return NULL; +} +void print_VkSubgroupFeatureFlagBits(const VkSubgroupFeatureFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkSubgroupFeatureFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +static const char* VkPeerMemoryFeatureFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT"; + case (1 << 1): return "VK_PEER_MEMORY_FEATURE_COPY_DST_BIT"; + case (1 << 2): return "VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT"; + case (1 << 3): return "VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT"; + } + return NULL; +} +void print_VkPeerMemoryFeatureFlagBits(const VkPeerMemoryFeatureFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkPeerMemoryFeatureFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +static const char* VkMemoryAllocateFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT"; + case (1 << 1): return "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT"; + case (1 << 2): return "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT"; + } + return NULL; +} +void print_VkMemoryAllocateFlagBits(const VkMemoryAllocateFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkMemoryAllocateFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +static const char* VkPointClippingBehavior_map(int o) { +switch (o) { + case 0: return "VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES"; + case 1: return "VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY"; + } + return NULL; +} +void print_VkPointClippingBehavior(const VkPointClippingBehavior* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkPointClippingBehavior_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +static const char* VkTessellationDomainOrigin_map(int o) { +switch (o) { + case 0: return "VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT"; + case 1: return "VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT"; + } + return NULL; +} +void print_VkTessellationDomainOrigin(const VkTessellationDomainOrigin* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkTessellationDomainOrigin_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +static const char* VkSamplerYcbcrModelConversion_map(int o) { +switch (o) { + case 0: return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY"; + case 1: return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY"; + case 2: return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709"; + case 3: return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601"; + case 4: return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020"; + } + return NULL; +} +void print_VkSamplerYcbcrModelConversion(const VkSamplerYcbcrModelConversion* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkSamplerYcbcrModelConversion_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +static const char* VkSamplerYcbcrRange_map(int o) { +switch (o) { + case 0: return "VK_SAMPLER_YCBCR_RANGE_ITU_FULL"; + case 1: return "VK_SAMPLER_YCBCR_RANGE_ITU_NARROW"; + } + return NULL; +} +void print_VkSamplerYcbcrRange(const VkSamplerYcbcrRange* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkSamplerYcbcrRange_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +static const char* VkChromaLocation_map(int o) { +switch (o) { + case 0: return "VK_CHROMA_LOCATION_COSITED_EVEN"; + case 1: return "VK_CHROMA_LOCATION_MIDPOINT"; + } + return NULL; +} +void print_VkChromaLocation(const VkChromaLocation* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkChromaLocation_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +static const char* VkExternalMemoryHandleTypeFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT"; + case (1 << 1): return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT"; + case (1 << 2): return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"; + case (1 << 3): return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT"; + case (1 << 4): return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT"; + case (1 << 5): return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT"; + case (1 << 6): return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT"; + case (1 << 9): return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT"; + case (1 << 10): return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID"; + case (1 << 7): return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT"; + case (1 << 8): return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT"; + case (1 << 11): return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA"; + case (1 << 12): return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV"; + case (1 << 13): return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_RESERVED_13_BIT_NV"; + } + return NULL; +} +void print_VkExternalMemoryHandleTypeFlagBits(const VkExternalMemoryHandleTypeFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkExternalMemoryHandleTypeFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +static const char* VkExternalMemoryFeatureFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT"; + case (1 << 1): return "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT"; + case (1 << 2): return "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT"; + } + return NULL; +} +void print_VkExternalMemoryFeatureFlagBits(const VkExternalMemoryFeatureFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkExternalMemoryFeatureFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +static const char* VkExternalFenceHandleTypeFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT"; + case (1 << 1): return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT"; + case (1 << 2): return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"; + case (1 << 3): return "VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT"; + case (1 << 4): return "VK_EXTERNAL_FENCE_HANDLE_TYPE_RESERVED_4_BIT_NV"; + case (1 << 5): return "VK_EXTERNAL_FENCE_HANDLE_TYPE_RESERVED_5_BIT_NV"; + } + return NULL; +} +void print_VkExternalFenceHandleTypeFlagBits(const VkExternalFenceHandleTypeFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkExternalFenceHandleTypeFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +static const char* VkExternalFenceFeatureFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT"; + case (1 << 1): return "VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT"; + } + return NULL; +} +void print_VkExternalFenceFeatureFlagBits(const VkExternalFenceFeatureFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkExternalFenceFeatureFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +static const char* VkFenceImportFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_FENCE_IMPORT_TEMPORARY_BIT"; + } + return NULL; +} +void print_VkFenceImportFlagBits(const VkFenceImportFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkFenceImportFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +static const char* VkSemaphoreImportFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_SEMAPHORE_IMPORT_TEMPORARY_BIT"; + } + return NULL; +} +void print_VkSemaphoreImportFlagBits(const VkSemaphoreImportFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkSemaphoreImportFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +static const char* VkExternalSemaphoreHandleTypeFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT"; + case (1 << 1): return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT"; + case (1 << 2): return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"; + case (1 << 3): return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT"; + case (1 << 4): return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT"; + case (1 << 7): return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA"; + case (1 << 5): return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_RESERVED_5_BIT_NV"; + case (1 << 6): return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_RESERVED_6_BIT_NV"; + } + return NULL; +} +void print_VkExternalSemaphoreHandleTypeFlagBits(const VkExternalSemaphoreHandleTypeFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkExternalSemaphoreHandleTypeFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +static const char* VkExternalSemaphoreFeatureFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT"; + case (1 << 1): return "VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT"; + } + return NULL; +} +void print_VkExternalSemaphoreFeatureFlagBits(const VkExternalSemaphoreFeatureFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkExternalSemaphoreFeatureFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkSubgroupFeatureFlags(const VkSubgroupFeatureFlags * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : ", str); + const unsigned int max_bits = 64; + unsigned int _count = 0; + unsigned int checkBit = 1; + unsigned int n = *obj; + while (n) { + n &= (n-1); + _count++; + } + unsigned int b = *obj; + checkBit = 1; + vk_json_printf(_OUT, "\""); + if (*obj == 0) vk_json_printf(_OUT, "0"); + for (unsigned int i = 0, bitCount = 0; i < max_bits; i++, checkBit <<= 1) { + unsigned int res = b & checkBit; + if (res) { + bitCount++; + if (bitCount < _count) { + vk_json_printf(_OUT, "%s | ", VkSubgroupFeatureFlagBits_map(1<sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->subgroupSize, "subgroupSize", 1); + + print_VkShaderStageFlags(&obj->supportedStages, "supportedStages", 1); + + print_VkSubgroupFeatureFlags(&obj->supportedOperations, "supportedOperations", 1); + + print_VkBool32(&obj->quadOperationsInAllStages, "quadOperationsInAllStages", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"buffer\" : \"\",\n"); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"memory\" : \"\",\n"); + + print_VkDeviceSize(&obj->memoryOffset, "memoryOffset", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkBindImageMemoryInfo(const VkBindImageMemoryInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"image\" : \"\",\n"); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"memory\" : \"\",\n"); + + print_VkDeviceSize(&obj->memoryOffset, "memoryOffset", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->storageBuffer16BitAccess, "storageBuffer16BitAccess", 1); + + print_VkBool32(&obj->uniformAndStorageBuffer16BitAccess, "uniformAndStorageBuffer16BitAccess", 1); + + print_VkBool32(&obj->storagePushConstant16, "storagePushConstant16", 1); + + print_VkBool32(&obj->storageInputOutput16, "storageInputOutput16", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->prefersDedicatedAllocation, "prefersDedicatedAllocation", 1); + + print_VkBool32(&obj->requiresDedicatedAllocation, "requiresDedicatedAllocation", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"image\" : \"\",\n"); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"buffer\" : \"\"\n"); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkMemoryAllocateFlags(&obj->flags, "flags", 1); + + print_uint32_t(&obj->deviceMask, "deviceMask", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->deviceMask, "deviceMask", 1); + + print_uint32_t(&obj->deviceRenderAreaCount, "deviceRenderAreaCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pDeviceRenderAreas\" :"); + if (obj->pDeviceRenderAreas) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->deviceRenderAreaCount); i++) { + if (i+1 == *(&obj->deviceRenderAreaCount)) + print_VkRect2D(&obj->pDeviceRenderAreas[i], "pDeviceRenderAreas", 0); + else + print_VkRect2D(&obj->pDeviceRenderAreas[i], "pDeviceRenderAreas", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkDeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->deviceMask, "deviceMask", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->waitSemaphoreCount, "waitSemaphoreCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pWaitSemaphoreDeviceIndices\" :"); + if (obj->pWaitSemaphoreDeviceIndices) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->waitSemaphoreCount); i++) { + char tmp[100]; + sprintf(tmp, "pWaitSemaphoreDeviceIndices_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->waitSemaphoreCount); + print_uint32_t(&obj->pWaitSemaphoreDeviceIndices[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->commandBufferCount, "commandBufferCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pCommandBufferDeviceMasks\" :"); + if (obj->pCommandBufferDeviceMasks) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->commandBufferCount); i++) { + char tmp[100]; + sprintf(tmp, "pCommandBufferDeviceMasks_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->commandBufferCount); + print_uint32_t(&obj->pCommandBufferDeviceMasks[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->signalSemaphoreCount, "signalSemaphoreCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pSignalSemaphoreDeviceIndices\" :"); + if (obj->pSignalSemaphoreDeviceIndices) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->signalSemaphoreCount); i++) { + char tmp[100]; + sprintf(tmp, "pSignalSemaphoreDeviceIndices_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->signalSemaphoreCount); + print_uint32_t(&obj->pSignalSemaphoreDeviceIndices[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->deviceIndexCount, "deviceIndexCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pDeviceIndices\" :"); + if (obj->pDeviceIndices) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->deviceIndexCount); i++) { + char tmp[100]; + sprintf(tmp, "pDeviceIndices_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->deviceIndexCount); + print_uint32_t(&obj->pDeviceIndices[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->deviceIndexCount, "deviceIndexCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pDeviceIndices\" :"); + if (obj->pDeviceIndices) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->deviceIndexCount); i++) { + char tmp[100]; + sprintf(tmp, "pDeviceIndices_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->deviceIndexCount); + print_uint32_t(&obj->pDeviceIndices[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->splitInstanceBindRegionCount, "splitInstanceBindRegionCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pSplitInstanceBindRegions\" :"); + if (obj->pSplitInstanceBindRegions) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->splitInstanceBindRegionCount); i++) { + if (i+1 == *(&obj->splitInstanceBindRegionCount)) + print_VkRect2D(&obj->pSplitInstanceBindRegions[i], "pSplitInstanceBindRegions", 0); + else + print_VkRect2D(&obj->pSplitInstanceBindRegions[i], "pSplitInstanceBindRegions", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->physicalDeviceCount, "physicalDeviceCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"physicalDevices\" :"); + if (obj->physicalDevices) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_MAX_DEVICE_GROUP_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "physicalDevices_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_MAX_DEVICE_GROUP_SIZE); + print_VkPhysicalDevice(&obj->physicalDevices[i], tmp, isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_VkBool32(&obj->subsetAllocation, "subsetAllocation", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->physicalDeviceCount, "physicalDeviceCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pPhysicalDevices\" :"); + if (obj->pPhysicalDevices) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->physicalDeviceCount); i++) { + char tmp[100]; + sprintf(tmp, "pPhysicalDevices_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->physicalDeviceCount); + print_VkPhysicalDevice(&obj->pPhysicalDevices[i], tmp, isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2 * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"buffer\" : \"\"\n"); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2 * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"image\" : \"\"\n"); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkMemoryRequirements2(const VkMemoryRequirements2 * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"memoryRequirements\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkMemoryRequirements(&obj->memoryRequirements, "memoryRequirements", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2 * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"features\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkPhysicalDeviceFeatures(&obj->features, "features", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2 * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"properties\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkPhysicalDeviceProperties(&obj->properties, "properties", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkFormatProperties2(const VkFormatProperties2 * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"formatProperties\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkFormatProperties(&obj->formatProperties, "formatProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkImageFormatProperties2(const VkImageFormatProperties2 * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"imageFormatProperties\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkImageFormatProperties(&obj->imageFormatProperties, "imageFormatProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2 * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkFormat(&obj->format, "format", 1); + + print_VkImageType(&obj->type, "type", 1); + + print_VkImageTiling(&obj->tiling, "tiling", 1); + + print_VkImageUsageFlags(&obj->usage, "usage", 1); + + print_VkImageCreateFlags(&obj->flags, "flags", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkQueueFamilyProperties2(const VkQueueFamilyProperties2 * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"queueFamilyProperties\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkQueueFamilyProperties(&obj->queueFamilyProperties, "queueFamilyProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2 * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"memoryProperties\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkPhysicalDeviceMemoryProperties(&obj->memoryProperties, "memoryProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPointClippingBehavior(&obj->pointClippingBehavior, "pointClippingBehavior", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkInputAttachmentAspectReference(const VkInputAttachmentAspectReference * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint32_t(&obj->subpass, "subpass", 1); + + print_uint32_t(&obj->inputAttachmentIndex, "inputAttachmentIndex", 1); + + print_VkImageAspectFlags(&obj->aspectMask, "aspectMask", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->aspectReferenceCount, "aspectReferenceCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pAspectReferences\" :"); + if (obj->pAspectReferences) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->aspectReferenceCount); i++) { + if (i+1 == *(&obj->aspectReferenceCount)) + print_VkInputAttachmentAspectReference(&obj->pAspectReferences[i], "pAspectReferences", 0); + else + print_VkInputAttachmentAspectReference(&obj->pAspectReferences[i], "pAspectReferences", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkImageUsageFlags(&obj->usage, "usage", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkTessellationDomainOrigin(&obj->domainOrigin, "domainOrigin", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->subpassCount, "subpassCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pViewMasks\" :"); + if (obj->pViewMasks) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->subpassCount); i++) { + char tmp[100]; + sprintf(tmp, "pViewMasks_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->subpassCount); + print_uint32_t(&obj->pViewMasks[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->dependencyCount, "dependencyCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pViewOffsets\" :"); + if (obj->pViewOffsets) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->dependencyCount); i++) { + char tmp[100]; + sprintf(tmp, "pViewOffsets_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->dependencyCount); + print_int32_t(&obj->pViewOffsets[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->correlationMaskCount, "correlationMaskCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pCorrelationMasks\" :"); + if (obj->pCorrelationMasks) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->correlationMaskCount); i++) { + char tmp[100]; + sprintf(tmp, "pCorrelationMasks_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->correlationMaskCount); + print_uint32_t(&obj->pCorrelationMasks[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->multiview, "multiview", 1); + + print_VkBool32(&obj->multiviewGeometryShader, "multiviewGeometryShader", 1); + + print_VkBool32(&obj->multiviewTessellationShader, "multiviewTessellationShader", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->maxMultiviewViewCount, "maxMultiviewViewCount", 1); + + print_uint32_t(&obj->maxMultiviewInstanceIndex, "maxMultiviewInstanceIndex", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->variablePointersStorageBuffer, "variablePointersStorageBuffer", 1); + + print_VkBool32(&obj->variablePointers, "variablePointers", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures; + +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->protectedMemory, "protectedMemory", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->protectedNoFault, "protectedNoFault", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkDeviceQueueInfo2(const VkDeviceQueueInfo2 * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDeviceQueueCreateFlags(&obj->flags, "flags", 1); + + print_uint32_t(&obj->queueFamilyIndex, "queueFamilyIndex", 1); + + print_uint32_t(&obj->queueIndex, "queueIndex", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkProtectedSubmitInfo(const VkProtectedSubmitInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->protectedSubmit, "protectedSubmit", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkFormat(&obj->format, "format", 1); + + print_VkSamplerYcbcrModelConversion(&obj->ycbcrModel, "ycbcrModel", 1); + + print_VkSamplerYcbcrRange(&obj->ycbcrRange, "ycbcrRange", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"components\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkComponentMapping(&obj->components, "components", 1); + } + + print_VkChromaLocation(&obj->xChromaOffset, "xChromaOffset", 1); + + print_VkChromaLocation(&obj->yChromaOffset, "yChromaOffset", 1); + + print_VkFilter(&obj->chromaFilter, "chromaFilter", 1); + + print_VkBool32(&obj->forceExplicitReconstruction, "forceExplicitReconstruction", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"conversion\" : \"\"\n"); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkImageAspectFlagBits(&obj->planeAspect, "planeAspect", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkImageAspectFlagBits(&obj->planeAspect, "planeAspect", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->samplerYcbcrConversion, "samplerYcbcrConversion", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->combinedImageSamplerDescriptorCount, "combinedImageSamplerDescriptorCount", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkExternalMemoryProperties(const VkExternalMemoryProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkExternalMemoryFeatureFlags(&obj->externalMemoryFeatures, "externalMemoryFeatures", 1); + + print_VkExternalMemoryHandleTypeFlags(&obj->exportFromImportedHandleTypes, "exportFromImportedHandleTypes", 1); + + print_VkExternalMemoryHandleTypeFlags(&obj->compatibleHandleTypes, "compatibleHandleTypes", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkExternalMemoryHandleTypeFlagBits(&obj->handleType, "handleType", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkExternalImageFormatProperties(const VkExternalImageFormatProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"externalMemoryProperties\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExternalMemoryProperties(&obj->externalMemoryProperties, "externalMemoryProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBufferCreateFlags(&obj->flags, "flags", 1); + + print_VkBufferUsageFlags(&obj->usage, "usage", 1); + + print_VkExternalMemoryHandleTypeFlagBits(&obj->handleType, "handleType", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkExternalBufferProperties(const VkExternalBufferProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"externalMemoryProperties\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExternalMemoryProperties(&obj->externalMemoryProperties, "externalMemoryProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"deviceUUID\" :"); + if (obj->deviceUUID) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_UUID_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "deviceUUID_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_UUID_SIZE); + print_uint8_t(&obj->deviceUUID[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"driverUUID\" :"); + if (obj->driverUUID) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_UUID_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "driverUUID_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_UUID_SIZE); + print_uint8_t(&obj->driverUUID[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"deviceLUID\" :"); + if (obj->deviceLUID) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_LUID_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "deviceLUID_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_LUID_SIZE); + print_uint8_t(&obj->deviceLUID[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->deviceNodeMask, "deviceNodeMask", 1); + + print_VkBool32(&obj->deviceLUIDValid, "deviceLUIDValid", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkExternalMemoryHandleTypeFlags(&obj->handleTypes, "handleTypes", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkExternalMemoryHandleTypeFlags(&obj->handleTypes, "handleTypes", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkExternalMemoryHandleTypeFlags(&obj->handleTypes, "handleTypes", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkExternalFenceHandleTypeFlagBits(&obj->handleType, "handleType", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkExternalFenceProperties(const VkExternalFenceProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkExternalFenceHandleTypeFlags(&obj->exportFromImportedHandleTypes, "exportFromImportedHandleTypes", 1); + + print_VkExternalFenceHandleTypeFlags(&obj->compatibleHandleTypes, "compatibleHandleTypes", 1); + + print_VkExternalFenceFeatureFlags(&obj->externalFenceFeatures, "externalFenceFeatures", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkExportFenceCreateInfo(const VkExportFenceCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkExternalFenceHandleTypeFlags(&obj->handleTypes, "handleTypes", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkExternalSemaphoreHandleTypeFlags(&obj->handleTypes, "handleTypes", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkExternalSemaphoreHandleTypeFlagBits(&obj->handleType, "handleType", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkExternalSemaphoreHandleTypeFlags(&obj->exportFromImportedHandleTypes, "exportFromImportedHandleTypes", 1); + + print_VkExternalSemaphoreHandleTypeFlags(&obj->compatibleHandleTypes, "compatibleHandleTypes", 1); + + print_VkExternalSemaphoreFeatureFlags(&obj->externalSemaphoreFeatures, "externalSemaphoreFeatures", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->maxPerSetDescriptors, "maxPerSetDescriptors", 1); + + print_VkDeviceSize(&obj->maxMemoryAllocationSize, "maxMemoryAllocationSize", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->supported, "supported", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->shaderDrawParameters, "shaderDrawParameters", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_1 +typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures; + +#endif +#ifdef VK_VERSION_1_2 +static const char* VkDriverId_map(int o) { +switch (o) { + case 1: return "VK_DRIVER_ID_AMD_PROPRIETARY"; + case 2: return "VK_DRIVER_ID_AMD_OPEN_SOURCE"; + case 3: return "VK_DRIVER_ID_MESA_RADV"; + case 4: return "VK_DRIVER_ID_NVIDIA_PROPRIETARY"; + case 5: return "VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS"; + case 6: return "VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA"; + case 7: return "VK_DRIVER_ID_IMAGINATION_PROPRIETARY"; + case 8: return "VK_DRIVER_ID_QUALCOMM_PROPRIETARY"; + case 9: return "VK_DRIVER_ID_ARM_PROPRIETARY"; + case 10: return "VK_DRIVER_ID_GOOGLE_SWIFTSHADER"; + case 11: return "VK_DRIVER_ID_GGP_PROPRIETARY"; + case 12: return "VK_DRIVER_ID_BROADCOM_PROPRIETARY"; + case 13: return "VK_DRIVER_ID_MESA_LLVMPIPE"; + case 14: return "VK_DRIVER_ID_MOLTENVK"; + case 15: return "VK_DRIVER_ID_COREAVI_PROPRIETARY"; + case 16: return "VK_DRIVER_ID_JUICE_PROPRIETARY"; + case 17: return "VK_DRIVER_ID_VERISILICON_PROPRIETARY"; + case 18: return "VK_DRIVER_ID_MESA_TURNIP"; + case 19: return "VK_DRIVER_ID_MESA_V3DV"; + case 20: return "VK_DRIVER_ID_MESA_PANVK"; + case 21: return "VK_DRIVER_ID_SAMSUNG_PROPRIETARY"; + } + return NULL; +} +void print_VkDriverId(const VkDriverId* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkDriverId_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +static const char* VkShaderFloatControlsIndependence_map(int o) { +switch (o) { + case 0: return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY"; + case 1: return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL"; + case 2: return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE"; + } + return NULL; +} +void print_VkShaderFloatControlsIndependence(const VkShaderFloatControlsIndependence* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkShaderFloatControlsIndependence_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +static const char* VkResolveModeFlagBits_map(int o) { +switch (o) { + case 0: return "VK_RESOLVE_MODE_NONE"; + case (1 << 0): return "VK_RESOLVE_MODE_SAMPLE_ZERO_BIT"; + case (1 << 1): return "VK_RESOLVE_MODE_AVERAGE_BIT"; + case (1 << 2): return "VK_RESOLVE_MODE_MIN_BIT"; + case (1 << 3): return "VK_RESOLVE_MODE_MAX_BIT"; + } + return NULL; +} +void print_VkResolveModeFlagBits(const VkResolveModeFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkResolveModeFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +static const char* VkDescriptorBindingFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT"; + case (1 << 1): return "VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT"; + case (1 << 2): return "VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT"; + case (1 << 3): return "VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT"; + case (1 << 4): return "VK_DESCRIPTOR_BINDING_RESERVED_4_BIT_QCOM"; + } + return NULL; +} +void print_VkDescriptorBindingFlagBits(const VkDescriptorBindingFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkDescriptorBindingFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +static const char* VkSamplerReductionMode_map(int o) { +switch (o) { + case 0: return "VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE"; + case 1: return "VK_SAMPLER_REDUCTION_MODE_MIN"; + case 2: return "VK_SAMPLER_REDUCTION_MODE_MAX"; + } + return NULL; +} +void print_VkSamplerReductionMode(const VkSamplerReductionMode* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkSamplerReductionMode_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +static const char* VkSemaphoreType_map(int o) { +switch (o) { + case 0: return "VK_SEMAPHORE_TYPE_BINARY"; + case 1: return "VK_SEMAPHORE_TYPE_TIMELINE"; + } + return NULL; +} +void print_VkSemaphoreType(const VkSemaphoreType* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkSemaphoreType_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +static const char* VkSemaphoreWaitFlagBits_map(int o) { +switch (o) { + case (1 << 0): return "VK_SEMAPHORE_WAIT_ANY_BIT"; + } + return NULL; +} +void print_VkSemaphoreWaitFlagBits(const VkSemaphoreWaitFlagBits* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkSemaphoreWaitFlagBits_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkResolveModeFlags(const VkResolveModeFlags * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : ", str); + const unsigned int max_bits = 64; + unsigned int _count = 0; + unsigned int checkBit = 1; + unsigned int n = *obj; + while (n) { + n &= (n-1); + _count++; + } + unsigned int b = *obj; + checkBit = 1; + vk_json_printf(_OUT, "\""); + if (*obj == 0) vk_json_printf(_OUT, "0"); + for (unsigned int i = 0, bitCount = 0; i < max_bits; i++, checkBit <<= 1) { + unsigned int res = b & checkBit; + if (res) { + bitCount++; + if (bitCount < _count) { + vk_json_printf(_OUT, "%s | ", VkResolveModeFlagBits_map(1<sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->storageBuffer16BitAccess, "storageBuffer16BitAccess", 1); + + print_VkBool32(&obj->uniformAndStorageBuffer16BitAccess, "uniformAndStorageBuffer16BitAccess", 1); + + print_VkBool32(&obj->storagePushConstant16, "storagePushConstant16", 1); + + print_VkBool32(&obj->storageInputOutput16, "storageInputOutput16", 1); + + print_VkBool32(&obj->multiview, "multiview", 1); + + print_VkBool32(&obj->multiviewGeometryShader, "multiviewGeometryShader", 1); + + print_VkBool32(&obj->multiviewTessellationShader, "multiviewTessellationShader", 1); + + print_VkBool32(&obj->variablePointersStorageBuffer, "variablePointersStorageBuffer", 1); + + print_VkBool32(&obj->variablePointers, "variablePointers", 1); + + print_VkBool32(&obj->protectedMemory, "protectedMemory", 1); + + print_VkBool32(&obj->samplerYcbcrConversion, "samplerYcbcrConversion", 1); + + print_VkBool32(&obj->shaderDrawParameters, "shaderDrawParameters", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"deviceUUID\" :"); + if (obj->deviceUUID) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_UUID_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "deviceUUID_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_UUID_SIZE); + print_uint8_t(&obj->deviceUUID[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"driverUUID\" :"); + if (obj->driverUUID) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_UUID_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "driverUUID_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_UUID_SIZE); + print_uint8_t(&obj->driverUUID[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"deviceLUID\" :"); + if (obj->deviceLUID) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_LUID_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "deviceLUID_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_LUID_SIZE); + print_uint8_t(&obj->deviceLUID[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->deviceNodeMask, "deviceNodeMask", 1); + + print_VkBool32(&obj->deviceLUIDValid, "deviceLUIDValid", 1); + + print_uint32_t(&obj->subgroupSize, "subgroupSize", 1); + + print_VkShaderStageFlags(&obj->subgroupSupportedStages, "subgroupSupportedStages", 1); + + print_VkSubgroupFeatureFlags(&obj->subgroupSupportedOperations, "subgroupSupportedOperations", 1); + + print_VkBool32(&obj->subgroupQuadOperationsInAllStages, "subgroupQuadOperationsInAllStages", 1); + + print_VkPointClippingBehavior(&obj->pointClippingBehavior, "pointClippingBehavior", 1); + + print_uint32_t(&obj->maxMultiviewViewCount, "maxMultiviewViewCount", 1); + + print_uint32_t(&obj->maxMultiviewInstanceIndex, "maxMultiviewInstanceIndex", 1); + + print_VkBool32(&obj->protectedNoFault, "protectedNoFault", 1); + + print_uint32_t(&obj->maxPerSetDescriptors, "maxPerSetDescriptors", 1); + + print_VkDeviceSize(&obj->maxMemoryAllocationSize, "maxMemoryAllocationSize", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->samplerMirrorClampToEdge, "samplerMirrorClampToEdge", 1); + + print_VkBool32(&obj->drawIndirectCount, "drawIndirectCount", 1); + + print_VkBool32(&obj->storageBuffer8BitAccess, "storageBuffer8BitAccess", 1); + + print_VkBool32(&obj->uniformAndStorageBuffer8BitAccess, "uniformAndStorageBuffer8BitAccess", 1); + + print_VkBool32(&obj->storagePushConstant8, "storagePushConstant8", 1); + + print_VkBool32(&obj->shaderBufferInt64Atomics, "shaderBufferInt64Atomics", 1); + + print_VkBool32(&obj->shaderSharedInt64Atomics, "shaderSharedInt64Atomics", 1); + + print_VkBool32(&obj->shaderFloat16, "shaderFloat16", 1); + + print_VkBool32(&obj->shaderInt8, "shaderInt8", 1); + + print_VkBool32(&obj->descriptorIndexing, "descriptorIndexing", 1); + + print_VkBool32(&obj->shaderInputAttachmentArrayDynamicIndexing, "shaderInputAttachmentArrayDynamicIndexing", 1); + + print_VkBool32(&obj->shaderUniformTexelBufferArrayDynamicIndexing, "shaderUniformTexelBufferArrayDynamicIndexing", 1); + + print_VkBool32(&obj->shaderStorageTexelBufferArrayDynamicIndexing, "shaderStorageTexelBufferArrayDynamicIndexing", 1); + + print_VkBool32(&obj->shaderUniformBufferArrayNonUniformIndexing, "shaderUniformBufferArrayNonUniformIndexing", 1); + + print_VkBool32(&obj->shaderSampledImageArrayNonUniformIndexing, "shaderSampledImageArrayNonUniformIndexing", 1); + + print_VkBool32(&obj->shaderStorageBufferArrayNonUniformIndexing, "shaderStorageBufferArrayNonUniformIndexing", 1); + + print_VkBool32(&obj->shaderStorageImageArrayNonUniformIndexing, "shaderStorageImageArrayNonUniformIndexing", 1); + + print_VkBool32(&obj->shaderInputAttachmentArrayNonUniformIndexing, "shaderInputAttachmentArrayNonUniformIndexing", 1); + + print_VkBool32(&obj->shaderUniformTexelBufferArrayNonUniformIndexing, "shaderUniformTexelBufferArrayNonUniformIndexing", 1); + + print_VkBool32(&obj->shaderStorageTexelBufferArrayNonUniformIndexing, "shaderStorageTexelBufferArrayNonUniformIndexing", 1); + + print_VkBool32(&obj->descriptorBindingUniformBufferUpdateAfterBind, "descriptorBindingUniformBufferUpdateAfterBind", 1); + + print_VkBool32(&obj->descriptorBindingSampledImageUpdateAfterBind, "descriptorBindingSampledImageUpdateAfterBind", 1); + + print_VkBool32(&obj->descriptorBindingStorageImageUpdateAfterBind, "descriptorBindingStorageImageUpdateAfterBind", 1); + + print_VkBool32(&obj->descriptorBindingStorageBufferUpdateAfterBind, "descriptorBindingStorageBufferUpdateAfterBind", 1); + + print_VkBool32(&obj->descriptorBindingUniformTexelBufferUpdateAfterBind, "descriptorBindingUniformTexelBufferUpdateAfterBind", 1); + + print_VkBool32(&obj->descriptorBindingStorageTexelBufferUpdateAfterBind, "descriptorBindingStorageTexelBufferUpdateAfterBind", 1); + + print_VkBool32(&obj->descriptorBindingUpdateUnusedWhilePending, "descriptorBindingUpdateUnusedWhilePending", 1); + + print_VkBool32(&obj->descriptorBindingPartiallyBound, "descriptorBindingPartiallyBound", 1); + + print_VkBool32(&obj->descriptorBindingVariableDescriptorCount, "descriptorBindingVariableDescriptorCount", 1); + + print_VkBool32(&obj->runtimeDescriptorArray, "runtimeDescriptorArray", 1); + + print_VkBool32(&obj->samplerFilterMinmax, "samplerFilterMinmax", 1); + + print_VkBool32(&obj->scalarBlockLayout, "scalarBlockLayout", 1); + + print_VkBool32(&obj->imagelessFramebuffer, "imagelessFramebuffer", 1); + + print_VkBool32(&obj->uniformBufferStandardLayout, "uniformBufferStandardLayout", 1); + + print_VkBool32(&obj->shaderSubgroupExtendedTypes, "shaderSubgroupExtendedTypes", 1); + + print_VkBool32(&obj->separateDepthStencilLayouts, "separateDepthStencilLayouts", 1); + + print_VkBool32(&obj->hostQueryReset, "hostQueryReset", 1); + + print_VkBool32(&obj->timelineSemaphore, "timelineSemaphore", 1); + + print_VkBool32(&obj->bufferDeviceAddress, "bufferDeviceAddress", 1); + + print_VkBool32(&obj->bufferDeviceAddressCaptureReplay, "bufferDeviceAddressCaptureReplay", 1); + + print_VkBool32(&obj->bufferDeviceAddressMultiDevice, "bufferDeviceAddressMultiDevice", 1); + + print_VkBool32(&obj->vulkanMemoryModel, "vulkanMemoryModel", 1); + + print_VkBool32(&obj->vulkanMemoryModelDeviceScope, "vulkanMemoryModelDeviceScope", 1); + + print_VkBool32(&obj->vulkanMemoryModelAvailabilityVisibilityChains, "vulkanMemoryModelAvailabilityVisibilityChains", 1); + + print_VkBool32(&obj->shaderOutputViewportIndex, "shaderOutputViewportIndex", 1); + + print_VkBool32(&obj->shaderOutputLayer, "shaderOutputLayer", 1); + + print_VkBool32(&obj->subgroupBroadcastDynamicId, "subgroupBroadcastDynamicId", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkConformanceVersion(const VkConformanceVersion * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint8_t(&obj->major, "major", 1); + + print_uint8_t(&obj->minor, "minor", 1); + + print_uint8_t(&obj->subminor, "subminor", 1); + + print_uint8_t(&obj->patch, "patch", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDriverId(&obj->driverID, "driverID", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"driverName\" :"); + if (obj->driverName) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_MAX_DRIVER_NAME_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "driverName_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_MAX_DRIVER_NAME_SIZE); + print_char(&obj->driverName[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"driverInfo\" :"); + if (obj->driverInfo) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_MAX_DRIVER_INFO_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "driverInfo_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_MAX_DRIVER_INFO_SIZE); + print_char(&obj->driverInfo[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"conformanceVersion\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkConformanceVersion(&obj->conformanceVersion, "conformanceVersion", 1); + } + + print_VkShaderFloatControlsIndependence(&obj->denormBehaviorIndependence, "denormBehaviorIndependence", 1); + + print_VkShaderFloatControlsIndependence(&obj->roundingModeIndependence, "roundingModeIndependence", 1); + + print_VkBool32(&obj->shaderSignedZeroInfNanPreserveFloat16, "shaderSignedZeroInfNanPreserveFloat16", 1); + + print_VkBool32(&obj->shaderSignedZeroInfNanPreserveFloat32, "shaderSignedZeroInfNanPreserveFloat32", 1); + + print_VkBool32(&obj->shaderSignedZeroInfNanPreserveFloat64, "shaderSignedZeroInfNanPreserveFloat64", 1); + + print_VkBool32(&obj->shaderDenormPreserveFloat16, "shaderDenormPreserveFloat16", 1); + + print_VkBool32(&obj->shaderDenormPreserveFloat32, "shaderDenormPreserveFloat32", 1); + + print_VkBool32(&obj->shaderDenormPreserveFloat64, "shaderDenormPreserveFloat64", 1); + + print_VkBool32(&obj->shaderDenormFlushToZeroFloat16, "shaderDenormFlushToZeroFloat16", 1); + + print_VkBool32(&obj->shaderDenormFlushToZeroFloat32, "shaderDenormFlushToZeroFloat32", 1); + + print_VkBool32(&obj->shaderDenormFlushToZeroFloat64, "shaderDenormFlushToZeroFloat64", 1); + + print_VkBool32(&obj->shaderRoundingModeRTEFloat16, "shaderRoundingModeRTEFloat16", 1); + + print_VkBool32(&obj->shaderRoundingModeRTEFloat32, "shaderRoundingModeRTEFloat32", 1); + + print_VkBool32(&obj->shaderRoundingModeRTEFloat64, "shaderRoundingModeRTEFloat64", 1); + + print_VkBool32(&obj->shaderRoundingModeRTZFloat16, "shaderRoundingModeRTZFloat16", 1); + + print_VkBool32(&obj->shaderRoundingModeRTZFloat32, "shaderRoundingModeRTZFloat32", 1); + + print_VkBool32(&obj->shaderRoundingModeRTZFloat64, "shaderRoundingModeRTZFloat64", 1); + + print_uint32_t(&obj->maxUpdateAfterBindDescriptorsInAllPools, "maxUpdateAfterBindDescriptorsInAllPools", 1); + + print_VkBool32(&obj->shaderUniformBufferArrayNonUniformIndexingNative, "shaderUniformBufferArrayNonUniformIndexingNative", 1); + + print_VkBool32(&obj->shaderSampledImageArrayNonUniformIndexingNative, "shaderSampledImageArrayNonUniformIndexingNative", 1); + + print_VkBool32(&obj->shaderStorageBufferArrayNonUniformIndexingNative, "shaderStorageBufferArrayNonUniformIndexingNative", 1); + + print_VkBool32(&obj->shaderStorageImageArrayNonUniformIndexingNative, "shaderStorageImageArrayNonUniformIndexingNative", 1); + + print_VkBool32(&obj->shaderInputAttachmentArrayNonUniformIndexingNative, "shaderInputAttachmentArrayNonUniformIndexingNative", 1); + + print_VkBool32(&obj->robustBufferAccessUpdateAfterBind, "robustBufferAccessUpdateAfterBind", 1); + + print_VkBool32(&obj->quadDivergentImplicitLod, "quadDivergentImplicitLod", 1); + + print_uint32_t(&obj->maxPerStageDescriptorUpdateAfterBindSamplers, "maxPerStageDescriptorUpdateAfterBindSamplers", 1); + + print_uint32_t(&obj->maxPerStageDescriptorUpdateAfterBindUniformBuffers, "maxPerStageDescriptorUpdateAfterBindUniformBuffers", 1); + + print_uint32_t(&obj->maxPerStageDescriptorUpdateAfterBindStorageBuffers, "maxPerStageDescriptorUpdateAfterBindStorageBuffers", 1); + + print_uint32_t(&obj->maxPerStageDescriptorUpdateAfterBindSampledImages, "maxPerStageDescriptorUpdateAfterBindSampledImages", 1); + + print_uint32_t(&obj->maxPerStageDescriptorUpdateAfterBindStorageImages, "maxPerStageDescriptorUpdateAfterBindStorageImages", 1); + + print_uint32_t(&obj->maxPerStageDescriptorUpdateAfterBindInputAttachments, "maxPerStageDescriptorUpdateAfterBindInputAttachments", 1); + + print_uint32_t(&obj->maxPerStageUpdateAfterBindResources, "maxPerStageUpdateAfterBindResources", 1); + + print_uint32_t(&obj->maxDescriptorSetUpdateAfterBindSamplers, "maxDescriptorSetUpdateAfterBindSamplers", 1); + + print_uint32_t(&obj->maxDescriptorSetUpdateAfterBindUniformBuffers, "maxDescriptorSetUpdateAfterBindUniformBuffers", 1); + + print_uint32_t(&obj->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", 1); + + print_uint32_t(&obj->maxDescriptorSetUpdateAfterBindStorageBuffers, "maxDescriptorSetUpdateAfterBindStorageBuffers", 1); + + print_uint32_t(&obj->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", 1); + + print_uint32_t(&obj->maxDescriptorSetUpdateAfterBindSampledImages, "maxDescriptorSetUpdateAfterBindSampledImages", 1); + + print_uint32_t(&obj->maxDescriptorSetUpdateAfterBindStorageImages, "maxDescriptorSetUpdateAfterBindStorageImages", 1); + + print_uint32_t(&obj->maxDescriptorSetUpdateAfterBindInputAttachments, "maxDescriptorSetUpdateAfterBindInputAttachments", 1); + + print_VkResolveModeFlags(&obj->supportedDepthResolveModes, "supportedDepthResolveModes", 1); + + print_VkResolveModeFlags(&obj->supportedStencilResolveModes, "supportedStencilResolveModes", 1); + + print_VkBool32(&obj->independentResolveNone, "independentResolveNone", 1); + + print_VkBool32(&obj->independentResolve, "independentResolve", 1); + + print_VkBool32(&obj->filterMinmaxSingleComponentFormats, "filterMinmaxSingleComponentFormats", 1); + + print_VkBool32(&obj->filterMinmaxImageComponentMapping, "filterMinmaxImageComponentMapping", 1); + + print_uint64_t(&obj->maxTimelineSemaphoreValueDifference, "maxTimelineSemaphoreValueDifference", 1); + + print_VkSampleCountFlags(&obj->framebufferIntegerColorSampleCounts, "framebufferIntegerColorSampleCounts", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->viewFormatCount, "viewFormatCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pViewFormats\" :"); + if (obj->pViewFormats) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->viewFormatCount); i++) { + char tmp[100]; + sprintf(tmp, "pViewFormats_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->viewFormatCount); + print_VkFormat(&obj->pViewFormats[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkAttachmentDescription2(const VkAttachmentDescription2 * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkAttachmentDescriptionFlags(&obj->flags, "flags", 1); + + print_VkFormat(&obj->format, "format", 1); + + print_VkSampleCountFlagBits(&obj->samples, "samples", 1); + + print_VkAttachmentLoadOp(&obj->loadOp, "loadOp", 1); + + print_VkAttachmentStoreOp(&obj->storeOp, "storeOp", 1); + + print_VkAttachmentLoadOp(&obj->stencilLoadOp, "stencilLoadOp", 1); + + print_VkAttachmentStoreOp(&obj->stencilStoreOp, "stencilStoreOp", 1); + + print_VkImageLayout(&obj->initialLayout, "initialLayout", 1); + + print_VkImageLayout(&obj->finalLayout, "finalLayout", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkAttachmentReference2(const VkAttachmentReference2 * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->attachment, "attachment", 1); + + print_VkImageLayout(&obj->layout, "layout", 1); + + print_VkImageAspectFlags(&obj->aspectMask, "aspectMask", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkSubpassDescription2(const VkSubpassDescription2 * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkSubpassDescriptionFlags(&obj->flags, "flags", 1); + + print_VkPipelineBindPoint(&obj->pipelineBindPoint, "pipelineBindPoint", 1); + + print_uint32_t(&obj->viewMask, "viewMask", 1); + + print_uint32_t(&obj->inputAttachmentCount, "inputAttachmentCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pInputAttachments\" :"); + if (obj->pInputAttachments) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->inputAttachmentCount); i++) { + if (i+1 == *(&obj->inputAttachmentCount)) + print_VkAttachmentReference2(&obj->pInputAttachments[i], "pInputAttachments", 0); + else + print_VkAttachmentReference2(&obj->pInputAttachments[i], "pInputAttachments", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->colorAttachmentCount, "colorAttachmentCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pColorAttachments\" :"); + if (obj->pColorAttachments) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->colorAttachmentCount); i++) { + if (i+1 == *(&obj->colorAttachmentCount)) + print_VkAttachmentReference2(&obj->pColorAttachments[i], "pColorAttachments", 0); + else + print_VkAttachmentReference2(&obj->pColorAttachments[i], "pColorAttachments", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pResolveAttachments\" :"); + if (obj->pResolveAttachments) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->colorAttachmentCount); i++) { + if (i+1 == *(&obj->colorAttachmentCount)) + print_VkAttachmentReference2(&obj->pResolveAttachments[i], "pResolveAttachments", 0); + else + print_VkAttachmentReference2(&obj->pResolveAttachments[i], "pResolveAttachments", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pDepthStencilAttachment\" :"); + if (obj->pDepthStencilAttachment) { + vk_json_printf(_OUT, "\n"); + print_VkAttachmentReference2(*(&obj->pDepthStencilAttachment), "pDepthStencilAttachment", 1); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->preserveAttachmentCount, "preserveAttachmentCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pPreserveAttachments\" :"); + if (obj->pPreserveAttachments) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->preserveAttachmentCount); i++) { + char tmp[100]; + sprintf(tmp, "pPreserveAttachments_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->preserveAttachmentCount); + print_uint32_t(&obj->pPreserveAttachments[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkSubpassDependency2(const VkSubpassDependency2 * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->srcSubpass, "srcSubpass", 1); + + print_uint32_t(&obj->dstSubpass, "dstSubpass", 1); + + print_VkPipelineStageFlags(&obj->srcStageMask, "srcStageMask", 1); + + print_VkPipelineStageFlags(&obj->dstStageMask, "dstStageMask", 1); + + print_VkAccessFlags(&obj->srcAccessMask, "srcAccessMask", 1); + + print_VkAccessFlags(&obj->dstAccessMask, "dstAccessMask", 1); + + print_VkDependencyFlags(&obj->dependencyFlags, "dependencyFlags", 1); + + print_int32_t(&obj->viewOffset, "viewOffset", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2 * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkRenderPassCreateFlags(&obj->flags, "flags", 1); + + print_uint32_t(&obj->attachmentCount, "attachmentCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pAttachments\" :"); + if (obj->pAttachments) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->attachmentCount); i++) { + if (i+1 == *(&obj->attachmentCount)) + print_VkAttachmentDescription2(&obj->pAttachments[i], "pAttachments", 0); + else + print_VkAttachmentDescription2(&obj->pAttachments[i], "pAttachments", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->subpassCount, "subpassCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pSubpasses\" :"); + if (obj->pSubpasses) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->subpassCount); i++) { + if (i+1 == *(&obj->subpassCount)) + print_VkSubpassDescription2(&obj->pSubpasses[i], "pSubpasses", 0); + else + print_VkSubpassDescription2(&obj->pSubpasses[i], "pSubpasses", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->dependencyCount, "dependencyCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pDependencies\" :"); + if (obj->pDependencies) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->dependencyCount); i++) { + if (i+1 == *(&obj->dependencyCount)) + print_VkSubpassDependency2(&obj->pDependencies[i], "pDependencies", 0); + else + print_VkSubpassDependency2(&obj->pDependencies[i], "pDependencies", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->correlatedViewMaskCount, "correlatedViewMaskCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pCorrelatedViewMasks\" :"); + if (obj->pCorrelatedViewMasks) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->correlatedViewMaskCount); i++) { + char tmp[100]; + sprintf(tmp, "pCorrelatedViewMasks_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->correlatedViewMaskCount); + print_uint32_t(&obj->pCorrelatedViewMasks[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkSubpassBeginInfo(const VkSubpassBeginInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkSubpassContents(&obj->contents, "contents", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkSubpassEndInfo(const VkSubpassEndInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->storageBuffer8BitAccess, "storageBuffer8BitAccess", 1); + + print_VkBool32(&obj->uniformAndStorageBuffer8BitAccess, "uniformAndStorageBuffer8BitAccess", 1); + + print_VkBool32(&obj->storagePushConstant8, "storagePushConstant8", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDriverId(&obj->driverID, "driverID", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"driverName\" :"); + if (obj->driverName) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_MAX_DRIVER_NAME_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "driverName_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_MAX_DRIVER_NAME_SIZE); + print_char(&obj->driverName[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"driverInfo\" :"); + if (obj->driverInfo) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_MAX_DRIVER_INFO_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "driverInfo_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_MAX_DRIVER_INFO_SIZE); + print_char(&obj->driverInfo[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"conformanceVersion\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkConformanceVersion(&obj->conformanceVersion, "conformanceVersion", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->shaderBufferInt64Atomics, "shaderBufferInt64Atomics", 1); + + print_VkBool32(&obj->shaderSharedInt64Atomics, "shaderSharedInt64Atomics", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->shaderFloat16, "shaderFloat16", 1); + + print_VkBool32(&obj->shaderInt8, "shaderInt8", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkShaderFloatControlsIndependence(&obj->denormBehaviorIndependence, "denormBehaviorIndependence", 1); + + print_VkShaderFloatControlsIndependence(&obj->roundingModeIndependence, "roundingModeIndependence", 1); + + print_VkBool32(&obj->shaderSignedZeroInfNanPreserveFloat16, "shaderSignedZeroInfNanPreserveFloat16", 1); + + print_VkBool32(&obj->shaderSignedZeroInfNanPreserveFloat32, "shaderSignedZeroInfNanPreserveFloat32", 1); + + print_VkBool32(&obj->shaderSignedZeroInfNanPreserveFloat64, "shaderSignedZeroInfNanPreserveFloat64", 1); + + print_VkBool32(&obj->shaderDenormPreserveFloat16, "shaderDenormPreserveFloat16", 1); + + print_VkBool32(&obj->shaderDenormPreserveFloat32, "shaderDenormPreserveFloat32", 1); + + print_VkBool32(&obj->shaderDenormPreserveFloat64, "shaderDenormPreserveFloat64", 1); + + print_VkBool32(&obj->shaderDenormFlushToZeroFloat16, "shaderDenormFlushToZeroFloat16", 1); + + print_VkBool32(&obj->shaderDenormFlushToZeroFloat32, "shaderDenormFlushToZeroFloat32", 1); + + print_VkBool32(&obj->shaderDenormFlushToZeroFloat64, "shaderDenormFlushToZeroFloat64", 1); + + print_VkBool32(&obj->shaderRoundingModeRTEFloat16, "shaderRoundingModeRTEFloat16", 1); + + print_VkBool32(&obj->shaderRoundingModeRTEFloat32, "shaderRoundingModeRTEFloat32", 1); + + print_VkBool32(&obj->shaderRoundingModeRTEFloat64, "shaderRoundingModeRTEFloat64", 1); + + print_VkBool32(&obj->shaderRoundingModeRTZFloat16, "shaderRoundingModeRTZFloat16", 1); + + print_VkBool32(&obj->shaderRoundingModeRTZFloat32, "shaderRoundingModeRTZFloat32", 1); + + print_VkBool32(&obj->shaderRoundingModeRTZFloat64, "shaderRoundingModeRTZFloat64", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkDescriptorSetLayoutBindingFlagsCreateInfo(const VkDescriptorSetLayoutBindingFlagsCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->bindingCount, "bindingCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pBindingFlags\" :"); + if (obj->pBindingFlags) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->bindingCount); i++) { + char tmp[100]; + sprintf(tmp, "pBindingFlags_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->bindingCount); + print_VkDescriptorBindingFlags(&obj->pBindingFlags[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->shaderInputAttachmentArrayDynamicIndexing, "shaderInputAttachmentArrayDynamicIndexing", 1); + + print_VkBool32(&obj->shaderUniformTexelBufferArrayDynamicIndexing, "shaderUniformTexelBufferArrayDynamicIndexing", 1); + + print_VkBool32(&obj->shaderStorageTexelBufferArrayDynamicIndexing, "shaderStorageTexelBufferArrayDynamicIndexing", 1); + + print_VkBool32(&obj->shaderUniformBufferArrayNonUniformIndexing, "shaderUniformBufferArrayNonUniformIndexing", 1); + + print_VkBool32(&obj->shaderSampledImageArrayNonUniformIndexing, "shaderSampledImageArrayNonUniformIndexing", 1); + + print_VkBool32(&obj->shaderStorageBufferArrayNonUniformIndexing, "shaderStorageBufferArrayNonUniformIndexing", 1); + + print_VkBool32(&obj->shaderStorageImageArrayNonUniformIndexing, "shaderStorageImageArrayNonUniformIndexing", 1); + + print_VkBool32(&obj->shaderInputAttachmentArrayNonUniformIndexing, "shaderInputAttachmentArrayNonUniformIndexing", 1); + + print_VkBool32(&obj->shaderUniformTexelBufferArrayNonUniformIndexing, "shaderUniformTexelBufferArrayNonUniformIndexing", 1); + + print_VkBool32(&obj->shaderStorageTexelBufferArrayNonUniformIndexing, "shaderStorageTexelBufferArrayNonUniformIndexing", 1); + + print_VkBool32(&obj->descriptorBindingUniformBufferUpdateAfterBind, "descriptorBindingUniformBufferUpdateAfterBind", 1); + + print_VkBool32(&obj->descriptorBindingSampledImageUpdateAfterBind, "descriptorBindingSampledImageUpdateAfterBind", 1); + + print_VkBool32(&obj->descriptorBindingStorageImageUpdateAfterBind, "descriptorBindingStorageImageUpdateAfterBind", 1); + + print_VkBool32(&obj->descriptorBindingStorageBufferUpdateAfterBind, "descriptorBindingStorageBufferUpdateAfterBind", 1); + + print_VkBool32(&obj->descriptorBindingUniformTexelBufferUpdateAfterBind, "descriptorBindingUniformTexelBufferUpdateAfterBind", 1); + + print_VkBool32(&obj->descriptorBindingStorageTexelBufferUpdateAfterBind, "descriptorBindingStorageTexelBufferUpdateAfterBind", 1); + + print_VkBool32(&obj->descriptorBindingUpdateUnusedWhilePending, "descriptorBindingUpdateUnusedWhilePending", 1); + + print_VkBool32(&obj->descriptorBindingPartiallyBound, "descriptorBindingPartiallyBound", 1); + + print_VkBool32(&obj->descriptorBindingVariableDescriptorCount, "descriptorBindingVariableDescriptorCount", 1); + + print_VkBool32(&obj->runtimeDescriptorArray, "runtimeDescriptorArray", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->maxUpdateAfterBindDescriptorsInAllPools, "maxUpdateAfterBindDescriptorsInAllPools", 1); + + print_VkBool32(&obj->shaderUniformBufferArrayNonUniformIndexingNative, "shaderUniformBufferArrayNonUniformIndexingNative", 1); + + print_VkBool32(&obj->shaderSampledImageArrayNonUniformIndexingNative, "shaderSampledImageArrayNonUniformIndexingNative", 1); + + print_VkBool32(&obj->shaderStorageBufferArrayNonUniformIndexingNative, "shaderStorageBufferArrayNonUniformIndexingNative", 1); + + print_VkBool32(&obj->shaderStorageImageArrayNonUniformIndexingNative, "shaderStorageImageArrayNonUniformIndexingNative", 1); + + print_VkBool32(&obj->shaderInputAttachmentArrayNonUniformIndexingNative, "shaderInputAttachmentArrayNonUniformIndexingNative", 1); + + print_VkBool32(&obj->robustBufferAccessUpdateAfterBind, "robustBufferAccessUpdateAfterBind", 1); + + print_VkBool32(&obj->quadDivergentImplicitLod, "quadDivergentImplicitLod", 1); + + print_uint32_t(&obj->maxPerStageDescriptorUpdateAfterBindSamplers, "maxPerStageDescriptorUpdateAfterBindSamplers", 1); + + print_uint32_t(&obj->maxPerStageDescriptorUpdateAfterBindUniformBuffers, "maxPerStageDescriptorUpdateAfterBindUniformBuffers", 1); + + print_uint32_t(&obj->maxPerStageDescriptorUpdateAfterBindStorageBuffers, "maxPerStageDescriptorUpdateAfterBindStorageBuffers", 1); + + print_uint32_t(&obj->maxPerStageDescriptorUpdateAfterBindSampledImages, "maxPerStageDescriptorUpdateAfterBindSampledImages", 1); + + print_uint32_t(&obj->maxPerStageDescriptorUpdateAfterBindStorageImages, "maxPerStageDescriptorUpdateAfterBindStorageImages", 1); + + print_uint32_t(&obj->maxPerStageDescriptorUpdateAfterBindInputAttachments, "maxPerStageDescriptorUpdateAfterBindInputAttachments", 1); + + print_uint32_t(&obj->maxPerStageUpdateAfterBindResources, "maxPerStageUpdateAfterBindResources", 1); + + print_uint32_t(&obj->maxDescriptorSetUpdateAfterBindSamplers, "maxDescriptorSetUpdateAfterBindSamplers", 1); + + print_uint32_t(&obj->maxDescriptorSetUpdateAfterBindUniformBuffers, "maxDescriptorSetUpdateAfterBindUniformBuffers", 1); + + print_uint32_t(&obj->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", 1); + + print_uint32_t(&obj->maxDescriptorSetUpdateAfterBindStorageBuffers, "maxDescriptorSetUpdateAfterBindStorageBuffers", 1); + + print_uint32_t(&obj->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", 1); + + print_uint32_t(&obj->maxDescriptorSetUpdateAfterBindSampledImages, "maxDescriptorSetUpdateAfterBindSampledImages", 1); + + print_uint32_t(&obj->maxDescriptorSetUpdateAfterBindStorageImages, "maxDescriptorSetUpdateAfterBindStorageImages", 1); + + print_uint32_t(&obj->maxDescriptorSetUpdateAfterBindInputAttachments, "maxDescriptorSetUpdateAfterBindInputAttachments", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkDescriptorSetVariableDescriptorCountAllocateInfo(const VkDescriptorSetVariableDescriptorCountAllocateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->descriptorSetCount, "descriptorSetCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pDescriptorCounts\" :"); + if (obj->pDescriptorCounts) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->descriptorSetCount); i++) { + char tmp[100]; + sprintf(tmp, "pDescriptorCounts_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->descriptorSetCount); + print_uint32_t(&obj->pDescriptorCounts[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkDescriptorSetVariableDescriptorCountLayoutSupport(const VkDescriptorSetVariableDescriptorCountLayoutSupport * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->maxVariableDescriptorCount, "maxVariableDescriptorCount", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkSubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkResolveModeFlagBits(&obj->depthResolveMode, "depthResolveMode", 1); + + print_VkResolveModeFlagBits(&obj->stencilResolveMode, "stencilResolveMode", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pDepthStencilResolveAttachment\" :"); + if (obj->pDepthStencilResolveAttachment) { + vk_json_printf(_OUT, "\n"); + print_VkAttachmentReference2(*(&obj->pDepthStencilResolveAttachment), "pDepthStencilResolveAttachment", 0); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkResolveModeFlags(&obj->supportedDepthResolveModes, "supportedDepthResolveModes", 1); + + print_VkResolveModeFlags(&obj->supportedStencilResolveModes, "supportedStencilResolveModes", 1); + + print_VkBool32(&obj->independentResolveNone, "independentResolveNone", 1); + + print_VkBool32(&obj->independentResolve, "independentResolve", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->scalarBlockLayout, "scalarBlockLayout", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkImageUsageFlags(&obj->stencilUsage, "stencilUsage", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkSamplerReductionMode(&obj->reductionMode, "reductionMode", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->filterMinmaxSingleComponentFormats, "filterMinmaxSingleComponentFormats", 1); + + print_VkBool32(&obj->filterMinmaxImageComponentMapping, "filterMinmaxImageComponentMapping", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->vulkanMemoryModel, "vulkanMemoryModel", 1); + + print_VkBool32(&obj->vulkanMemoryModelDeviceScope, "vulkanMemoryModelDeviceScope", 1); + + print_VkBool32(&obj->vulkanMemoryModelAvailabilityVisibilityChains, "vulkanMemoryModelAvailabilityVisibilityChains", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->imagelessFramebuffer, "imagelessFramebuffer", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkFramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkImageCreateFlags(&obj->flags, "flags", 1); + + print_VkImageUsageFlags(&obj->usage, "usage", 1); + + print_uint32_t(&obj->width, "width", 1); + + print_uint32_t(&obj->height, "height", 1); + + print_uint32_t(&obj->layerCount, "layerCount", 1); + + print_uint32_t(&obj->viewFormatCount, "viewFormatCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pViewFormats\" :"); + if (obj->pViewFormats) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->viewFormatCount); i++) { + char tmp[100]; + sprintf(tmp, "pViewFormats_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->viewFormatCount); + print_VkFormat(&obj->pViewFormats[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkFramebufferAttachmentsCreateInfo(const VkFramebufferAttachmentsCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->attachmentImageInfoCount, "attachmentImageInfoCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pAttachmentImageInfos\" :"); + if (obj->pAttachmentImageInfos) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->attachmentImageInfoCount); i++) { + if (i+1 == *(&obj->attachmentImageInfoCount)) + print_VkFramebufferAttachmentImageInfo(&obj->pAttachmentImageInfos[i], "pAttachmentImageInfos", 0); + else + print_VkFramebufferAttachmentImageInfo(&obj->pAttachmentImageInfos[i], "pAttachmentImageInfos", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->attachmentCount, "attachmentCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pAttachments\" :"); + if (obj->pAttachments) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->attachmentCount); i++) { + char tmp[100]; + sprintf(tmp, "pAttachments_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->attachmentCount); + print_VkImageView(&obj->pAttachments[i], tmp, isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->uniformBufferStandardLayout, "uniformBufferStandardLayout", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->shaderSubgroupExtendedTypes, "shaderSubgroupExtendedTypes", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->separateDepthStencilLayouts, "separateDepthStencilLayouts", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkImageLayout(&obj->stencilLayout, "stencilLayout", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkImageLayout(&obj->stencilInitialLayout, "stencilInitialLayout", 1); + + print_VkImageLayout(&obj->stencilFinalLayout, "stencilFinalLayout", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->hostQueryReset, "hostQueryReset", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->timelineSemaphore, "timelineSemaphore", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint64_t(&obj->maxTimelineSemaphoreValueDifference, "maxTimelineSemaphoreValueDifference", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkSemaphoreType(&obj->semaphoreType, "semaphoreType", 1); + + print_uint64_t(&obj->initialValue, "initialValue", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkTimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->waitSemaphoreValueCount, "waitSemaphoreValueCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pWaitSemaphoreValues\" :"); + if (obj->pWaitSemaphoreValues) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->waitSemaphoreValueCount); i++) { + char tmp[100]; + sprintf(tmp, "pWaitSemaphoreValues_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->waitSemaphoreValueCount); + print_uint64_t(&obj->pWaitSemaphoreValues[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->signalSemaphoreValueCount, "signalSemaphoreValueCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pSignalSemaphoreValues\" :"); + if (obj->pSignalSemaphoreValues) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->signalSemaphoreValueCount); i++) { + char tmp[100]; + sprintf(tmp, "pSignalSemaphoreValues_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->signalSemaphoreValueCount); + print_uint64_t(&obj->pSignalSemaphoreValues[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkSemaphoreWaitFlags(&obj->flags, "flags", 1); + + print_uint32_t(&obj->semaphoreCount, "semaphoreCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pSemaphores\" :"); + if (obj->pSemaphores) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->semaphoreCount); i++) { + char tmp[100]; + sprintf(tmp, "pSemaphores_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->semaphoreCount); + print_VkSemaphore(&obj->pSemaphores[i], tmp, isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pValues\" :"); + if (obj->pValues) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->semaphoreCount); i++) { + char tmp[100]; + sprintf(tmp, "pValues_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->semaphoreCount); + print_uint64_t(&obj->pValues[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"semaphore\" : \"\",\n"); + + print_uint64_t(&obj->value, "value", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->bufferDeviceAddress, "bufferDeviceAddress", 1); + + print_VkBool32(&obj->bufferDeviceAddressCaptureReplay, "bufferDeviceAddressCaptureReplay", 1); + + print_VkBool32(&obj->bufferDeviceAddressMultiDevice, "bufferDeviceAddressMultiDevice", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkBufferDeviceAddressInfo(const VkBufferDeviceAddressInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"buffer\" : \"\"\n"); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkBufferOpaqueCaptureAddressCreateInfo(const VkBufferOpaqueCaptureAddressCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint64_t(&obj->opaqueCaptureAddress, "opaqueCaptureAddress", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkMemoryOpaqueCaptureAddressAllocateInfo(const VkMemoryOpaqueCaptureAddressAllocateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint64_t(&obj->opaqueCaptureAddress, "opaqueCaptureAddress", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_VERSION_1_2 +void print_VkDeviceMemoryOpaqueCaptureAddressInfo(const VkDeviceMemoryOpaqueCaptureAddressInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"memory\" : \"\"\n"); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VKSC_VERSION_1_0 +static const char* VkFaultLevel_map(int o) { +switch (o) { + case 0: return "VK_FAULT_LEVEL_UNASSIGNED"; + case 1: return "VK_FAULT_LEVEL_CRITICAL"; + case 2: return "VK_FAULT_LEVEL_RECOVERABLE"; + case 3: return "VK_FAULT_LEVEL_WARNING"; + } + return NULL; +} +void print_VkFaultLevel(const VkFaultLevel* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkFaultLevel_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VKSC_VERSION_1_0 +static const char* VkFaultType_map(int o) { +switch (o) { + case 0: return "VK_FAULT_TYPE_INVALID"; + case 1: return "VK_FAULT_TYPE_UNASSIGNED"; + case 2: return "VK_FAULT_TYPE_IMPLEMENTATION"; + case 3: return "VK_FAULT_TYPE_SYSTEM"; + case 4: return "VK_FAULT_TYPE_PHYSICAL_DEVICE"; + case 5: return "VK_FAULT_TYPE_COMMAND_BUFFER_FULL"; + case 6: return "VK_FAULT_TYPE_INVALID_API_USAGE"; + } + return NULL; +} +void print_VkFaultType(const VkFaultType* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkFaultType_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VKSC_VERSION_1_0 +static const char* VkFaultQueryBehavior_map(int o) { +switch (o) { + case 0: return "VK_FAULT_QUERY_BEHAVIOR_GET_AND_CLEAR_ALL_FAULTS"; + } + return NULL; +} +void print_VkFaultQueryBehavior(const VkFaultQueryBehavior* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkFaultQueryBehavior_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VKSC_VERSION_1_0 +static const char* VkPipelineMatchControl_map(int o) { +switch (o) { + case 0: return "VK_PIPELINE_MATCH_CONTROL_APPLICATION_UUID_EXACT_MATCH"; + } + return NULL; +} +void print_VkPipelineMatchControl(const VkPipelineMatchControl* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkPipelineMatchControl_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VKSC_VERSION_1_0 +static const char* VkPipelineCacheValidationVersion_map(int o) { +switch (o) { + case 1: return "VK_PIPELINE_CACHE_VALIDATION_VERSION_SAFETY_CRITICAL_ONE"; + } + return NULL; +} +void print_VkPipelineCacheValidationVersion(const VkPipelineCacheValidationVersion* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkPipelineCacheValidationVersion_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VKSC_VERSION_1_0 +void print_VkPhysicalDeviceVulkanSC10Features(const VkPhysicalDeviceVulkanSC10Features * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->shaderAtomicInstructions, "shaderAtomicInstructions", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VKSC_VERSION_1_0 +void print_VkPhysicalDeviceVulkanSC10Properties(const VkPhysicalDeviceVulkanSC10Properties * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->deviceNoDynamicHostAllocations, "deviceNoDynamicHostAllocations", 1); + + print_VkBool32(&obj->deviceDestroyFreesMemory, "deviceDestroyFreesMemory", 1); + + print_VkBool32(&obj->commandPoolMultipleCommandBuffersRecording, "commandPoolMultipleCommandBuffersRecording", 1); + + print_VkBool32(&obj->commandPoolResetCommandBuffer, "commandPoolResetCommandBuffer", 1); + + print_VkBool32(&obj->commandBufferSimultaneousUse, "commandBufferSimultaneousUse", 1); + + print_VkBool32(&obj->secondaryCommandBufferNullOrImagelessFramebuffer, "secondaryCommandBufferNullOrImagelessFramebuffer", 1); + + print_VkBool32(&obj->recycleDescriptorSetMemory, "recycleDescriptorSetMemory", 1); + + print_VkBool32(&obj->recyclePipelineMemory, "recyclePipelineMemory", 1); + + print_uint32_t(&obj->maxRenderPassSubpasses, "maxRenderPassSubpasses", 1); + + print_uint32_t(&obj->maxRenderPassDependencies, "maxRenderPassDependencies", 1); + + print_uint32_t(&obj->maxSubpassInputAttachments, "maxSubpassInputAttachments", 1); + + print_uint32_t(&obj->maxSubpassPreserveAttachments, "maxSubpassPreserveAttachments", 1); + + print_uint32_t(&obj->maxFramebufferAttachments, "maxFramebufferAttachments", 1); + + print_uint32_t(&obj->maxDescriptorSetLayoutBindings, "maxDescriptorSetLayoutBindings", 1); + + print_uint32_t(&obj->maxQueryFaultCount, "maxQueryFaultCount", 1); + + print_uint32_t(&obj->maxCallbackFaultCount, "maxCallbackFaultCount", 1); + + print_uint32_t(&obj->maxCommandPoolCommandBuffers, "maxCommandPoolCommandBuffers", 1); + + print_VkDeviceSize(&obj->maxCommandBufferSize, "maxCommandBufferSize", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VKSC_VERSION_1_0 +void print_VkPipelinePoolSize(const VkPipelinePoolSize * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDeviceSize(&obj->poolEntrySize, "poolEntrySize", 1); + + print_uint32_t(&obj->poolEntryCount, "poolEntryCount", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VKSC_VERSION_1_0 +void print_VkDeviceObjectReservationCreateInfo(const VkDeviceObjectReservationCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->pipelineCacheCreateInfoCount, "pipelineCacheCreateInfoCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pPipelineCacheCreateInfos\" :"); + if (obj->pPipelineCacheCreateInfos) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->pipelineCacheCreateInfoCount); i++) { + if (i+1 == *(&obj->pipelineCacheCreateInfoCount)) + print_VkPipelineCacheCreateInfo(&obj->pPipelineCacheCreateInfos[i], "pPipelineCacheCreateInfos", 0); + else + print_VkPipelineCacheCreateInfo(&obj->pPipelineCacheCreateInfos[i], "pPipelineCacheCreateInfos", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->pipelinePoolSizeCount, "pipelinePoolSizeCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pPipelinePoolSizes\" :"); + if (obj->pPipelinePoolSizes) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->pipelinePoolSizeCount); i++) { + if (i+1 == *(&obj->pipelinePoolSizeCount)) + print_VkPipelinePoolSize(&obj->pPipelinePoolSizes[i], "pPipelinePoolSizes", 0); + else + print_VkPipelinePoolSize(&obj->pPipelinePoolSizes[i], "pPipelinePoolSizes", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->semaphoreRequestCount, "semaphoreRequestCount", 1); + + print_uint32_t(&obj->commandBufferRequestCount, "commandBufferRequestCount", 1); + + print_uint32_t(&obj->fenceRequestCount, "fenceRequestCount", 1); + + print_uint32_t(&obj->deviceMemoryRequestCount, "deviceMemoryRequestCount", 1); + + print_uint32_t(&obj->bufferRequestCount, "bufferRequestCount", 1); + + print_uint32_t(&obj->imageRequestCount, "imageRequestCount", 1); + + print_uint32_t(&obj->eventRequestCount, "eventRequestCount", 1); + + print_uint32_t(&obj->queryPoolRequestCount, "queryPoolRequestCount", 1); + + print_uint32_t(&obj->bufferViewRequestCount, "bufferViewRequestCount", 1); + + print_uint32_t(&obj->imageViewRequestCount, "imageViewRequestCount", 1); + + print_uint32_t(&obj->layeredImageViewRequestCount, "layeredImageViewRequestCount", 1); + + print_uint32_t(&obj->pipelineCacheRequestCount, "pipelineCacheRequestCount", 1); + + print_uint32_t(&obj->pipelineLayoutRequestCount, "pipelineLayoutRequestCount", 1); + + print_uint32_t(&obj->renderPassRequestCount, "renderPassRequestCount", 1); + + print_uint32_t(&obj->graphicsPipelineRequestCount, "graphicsPipelineRequestCount", 1); + + print_uint32_t(&obj->computePipelineRequestCount, "computePipelineRequestCount", 1); + + print_uint32_t(&obj->descriptorSetLayoutRequestCount, "descriptorSetLayoutRequestCount", 1); + + print_uint32_t(&obj->samplerRequestCount, "samplerRequestCount", 1); + + print_uint32_t(&obj->descriptorPoolRequestCount, "descriptorPoolRequestCount", 1); + + print_uint32_t(&obj->descriptorSetRequestCount, "descriptorSetRequestCount", 1); + + print_uint32_t(&obj->framebufferRequestCount, "framebufferRequestCount", 1); + + print_uint32_t(&obj->commandPoolRequestCount, "commandPoolRequestCount", 1); + + print_uint32_t(&obj->samplerYcbcrConversionRequestCount, "samplerYcbcrConversionRequestCount", 1); + + print_uint32_t(&obj->surfaceRequestCount, "surfaceRequestCount", 1); + + print_uint32_t(&obj->swapchainRequestCount, "swapchainRequestCount", 1); + + print_uint32_t(&obj->displayModeRequestCount, "displayModeRequestCount", 1); + + print_uint32_t(&obj->subpassDescriptionRequestCount, "subpassDescriptionRequestCount", 1); + + print_uint32_t(&obj->attachmentDescriptionRequestCount, "attachmentDescriptionRequestCount", 1); + + print_uint32_t(&obj->descriptorSetLayoutBindingRequestCount, "descriptorSetLayoutBindingRequestCount", 1); + + print_uint32_t(&obj->descriptorSetLayoutBindingLimit, "descriptorSetLayoutBindingLimit", 1); + + print_uint32_t(&obj->maxImageViewMipLevels, "maxImageViewMipLevels", 1); + + print_uint32_t(&obj->maxImageViewArrayLayers, "maxImageViewArrayLayers", 1); + + print_uint32_t(&obj->maxLayeredImageViewMipLevels, "maxLayeredImageViewMipLevels", 1); + + print_uint32_t(&obj->maxOcclusionQueriesPerPool, "maxOcclusionQueriesPerPool", 1); + + print_uint32_t(&obj->maxPipelineStatisticsQueriesPerPool, "maxPipelineStatisticsQueriesPerPool", 1); + + print_uint32_t(&obj->maxTimestampQueriesPerPool, "maxTimestampQueriesPerPool", 1); + + print_uint32_t(&obj->maxImmutableSamplersPerDescriptorSetLayout, "maxImmutableSamplersPerDescriptorSetLayout", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VKSC_VERSION_1_0 +void print_VkCommandPoolMemoryReservationCreateInfo(const VkCommandPoolMemoryReservationCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDeviceSize(&obj->commandPoolReservedSize, "commandPoolReservedSize", 1); + + print_uint32_t(&obj->commandPoolMaxCommandBuffers, "commandPoolMaxCommandBuffers", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VKSC_VERSION_1_0 +void print_VkCommandPoolMemoryConsumption(const VkCommandPoolMemoryConsumption * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDeviceSize(&obj->commandPoolAllocated, "commandPoolAllocated", 1); + + print_VkDeviceSize(&obj->commandPoolReservedSize, "commandPoolReservedSize", 1); + + print_VkDeviceSize(&obj->commandBufferAllocated, "commandBufferAllocated", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VKSC_VERSION_1_0 +void print_VkFaultData(const VkFaultData * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkFaultLevel(&obj->faultLevel, "faultLevel", 1); + + print_VkFaultType(&obj->faultType, "faultType", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VKSC_VERSION_1_0 +void print_VkFaultCallbackInfo(const VkFaultCallbackInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->faultCount, "faultCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pFaults\" :"); + if (obj->pFaults) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->faultCount); i++) { + if (i+1 == *(&obj->faultCount)) + print_VkFaultData(&obj->pFaults[i], "pFaults", 0); + else + print_VkFaultData(&obj->pFaults[i], "pFaults", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + /** Note: Ignoring function pointer (PFN_vkFaultCallbackFunction). **/ + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VKSC_VERSION_1_0 +void print_VkPipelineOfflineCreateInfo(const VkPipelineOfflineCreateInfo * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pipelineIdentifier\" :"); + if (obj->pipelineIdentifier) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_UUID_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "pipelineIdentifier_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_UUID_SIZE); + print_uint8_t(&obj->pipelineIdentifier[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_VkPipelineMatchControl(&obj->matchControl, "matchControl", 1); + + print_VkDeviceSize(&obj->poolEntrySize, "poolEntrySize", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VKSC_VERSION_1_0 +void print_VkPipelineCacheStageValidationIndexEntry(const VkPipelineCacheStageValidationIndexEntry * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint64_t(&obj->codeSize, "codeSize", 1); + + print_uint64_t(&obj->codeOffset, "codeOffset", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VKSC_VERSION_1_0 +void print_VkPipelineCacheSafetyCriticalIndexEntry(const VkPipelineCacheSafetyCriticalIndexEntry * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pipelineIdentifier\" :"); + if (obj->pipelineIdentifier) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_UUID_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "pipelineIdentifier_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_UUID_SIZE); + print_uint8_t(&obj->pipelineIdentifier[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint64_t(&obj->pipelineMemorySize, "pipelineMemorySize", 1); + + print_uint64_t(&obj->jsonSize, "jsonSize", 1); + + print_uint64_t(&obj->jsonOffset, "jsonOffset", 1); + + print_uint32_t(&obj->stageIndexCount, "stageIndexCount", 1); + + print_uint32_t(&obj->stageIndexStride, "stageIndexStride", 1); + + print_uint64_t(&obj->stageIndexOffset, "stageIndexOffset", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VKSC_VERSION_1_0 +void print_VkPipelineCacheHeaderVersionSafetyCriticalOne(const VkPipelineCacheHeaderVersionSafetyCriticalOne * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + PRINT_SPACE + vk_json_printf(_OUT, "\"headerVersionOne\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkPipelineCacheHeaderVersionOne(&obj->headerVersionOne, "headerVersionOne", 1); + } + + print_VkPipelineCacheValidationVersion(&obj->validationVersion, "validationVersion", 1); + + print_uint32_t(&obj->implementationData, "implementationData", 1); + + print_uint32_t(&obj->pipelineIndexCount, "pipelineIndexCount", 1); + + print_uint32_t(&obj->pipelineIndexStride, "pipelineIndexStride", 1); + + print_uint64_t(&obj->pipelineIndexOffset, "pipelineIndexOffset", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_surface +void print_VkSurfaceKHR(const VkSurfaceKHR * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_surface +static const char* VkSurfaceTransformFlagBitsKHR_map(int o) { +switch (o) { + case (1 << 0): return "VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR"; + case (1 << 1): return "VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR"; + case (1 << 2): return "VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR"; + case (1 << 3): return "VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR"; + case (1 << 4): return "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR"; + case (1 << 5): return "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR"; + case (1 << 6): return "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR"; + case (1 << 7): return "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR"; + case (1 << 8): return "VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR"; + } + return NULL; +} +void print_VkSurfaceTransformFlagBitsKHR(const VkSurfaceTransformFlagBitsKHR* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkSurfaceTransformFlagBitsKHR_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_surface +static const char* VkPresentModeKHR_map(int o) { +switch (o) { + case 0: return "VK_PRESENT_MODE_IMMEDIATE_KHR"; + case 1: return "VK_PRESENT_MODE_MAILBOX_KHR"; + case 2: return "VK_PRESENT_MODE_FIFO_KHR"; + case 3: return "VK_PRESENT_MODE_FIFO_RELAXED_KHR"; + case 1000111000: return "VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR"; + case 1000111001: return "VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR"; + } + return NULL; +} +void print_VkPresentModeKHR(const VkPresentModeKHR* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkPresentModeKHR_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_surface +static const char* VkColorSpaceKHR_map(int o) { +switch (o) { + case 0: return "VK_COLOR_SPACE_SRGB_NONLINEAR_KHR"; + case 1000104001: return "VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT"; + case 1000104002: return "VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT"; + case 1000104003: return "VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT"; + case 1000104004: return "VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT"; + case 1000104005: return "VK_COLOR_SPACE_BT709_LINEAR_EXT"; + case 1000104006: return "VK_COLOR_SPACE_BT709_NONLINEAR_EXT"; + case 1000104007: return "VK_COLOR_SPACE_BT2020_LINEAR_EXT"; + case 1000104008: return "VK_COLOR_SPACE_HDR10_ST2084_EXT"; + case 1000104009: return "VK_COLOR_SPACE_DOLBYVISION_EXT"; + case 1000104010: return "VK_COLOR_SPACE_HDR10_HLG_EXT"; + case 1000104011: return "VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT"; + case 1000104012: return "VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT"; + case 1000104013: return "VK_COLOR_SPACE_PASS_THROUGH_EXT"; + case 1000104014: return "VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT"; + case 1000213000: return "VK_COLOR_SPACE_DISPLAY_NATIVE_AMD"; + } + return NULL; +} +void print_VkColorSpaceKHR(const VkColorSpaceKHR* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkColorSpaceKHR_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_surface +static const char* VkCompositeAlphaFlagBitsKHR_map(int o) { +switch (o) { + case (1 << 0): return "VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR"; + case (1 << 1): return "VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR"; + case (1 << 2): return "VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR"; + case (1 << 3): return "VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR"; + } + return NULL; +} +void print_VkCompositeAlphaFlagBitsKHR(const VkCompositeAlphaFlagBitsKHR* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkCompositeAlphaFlagBitsKHR_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_surface +void print_VkCompositeAlphaFlagsKHR(const VkCompositeAlphaFlagsKHR * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : ", str); + const unsigned int max_bits = 64; + unsigned int _count = 0; + unsigned int checkBit = 1; + unsigned int n = *obj; + while (n) { + n &= (n-1); + _count++; + } + unsigned int b = *obj; + checkBit = 1; + vk_json_printf(_OUT, "\""); + if (*obj == 0) vk_json_printf(_OUT, "0"); + for (unsigned int i = 0, bitCount = 0; i < max_bits; i++, checkBit <<= 1) { + unsigned int res = b & checkBit; + if (res) { + bitCount++; + if (bitCount < _count) { + vk_json_printf(_OUT, "%s | ", VkCompositeAlphaFlagBitsKHR_map(1<minImageCount, "minImageCount", 1); + + print_uint32_t(&obj->maxImageCount, "maxImageCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"currentExtent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->currentExtent, "currentExtent", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"minImageExtent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->minImageExtent, "minImageExtent", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"maxImageExtent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->maxImageExtent, "maxImageExtent", 1); + } + + print_uint32_t(&obj->maxImageArrayLayers, "maxImageArrayLayers", 1); + + print_VkSurfaceTransformFlagsKHR(&obj->supportedTransforms, "supportedTransforms", 1); + + print_VkSurfaceTransformFlagBitsKHR(&obj->currentTransform, "currentTransform", 1); + + print_VkCompositeAlphaFlagsKHR(&obj->supportedCompositeAlpha, "supportedCompositeAlpha", 1); + + print_VkImageUsageFlags(&obj->supportedUsageFlags, "supportedUsageFlags", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_surface +void print_VkSurfaceFormatKHR(const VkSurfaceFormatKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkFormat(&obj->format, "format", 1); + + print_VkColorSpaceKHR(&obj->colorSpace, "colorSpace", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_swapchain +void print_VkSwapchainKHR(const VkSwapchainKHR * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_swapchain +static const char* VkSwapchainCreateFlagBitsKHR_map(int o) { +switch (o) { + case (1 << 0): return "VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR"; + case (1 << 1): return "VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR"; + case (1 << 2): return "VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR"; + } + return NULL; +} +void print_VkSwapchainCreateFlagBitsKHR(const VkSwapchainCreateFlagBitsKHR* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkSwapchainCreateFlagBitsKHR_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_swapchain +static const char* VkDeviceGroupPresentModeFlagBitsKHR_map(int o) { +switch (o) { + case (1 << 0): return "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR"; + case (1 << 1): return "VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR"; + case (1 << 2): return "VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR"; + case (1 << 3): return "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR"; + } + return NULL; +} +void print_VkDeviceGroupPresentModeFlagBitsKHR(const VkDeviceGroupPresentModeFlagBitsKHR* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkDeviceGroupPresentModeFlagBitsKHR_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_swapchain +void print_VkSwapchainCreateFlagsKHR(const VkSwapchainCreateFlagsKHR * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : ", str); + const unsigned int max_bits = 64; + unsigned int _count = 0; + unsigned int checkBit = 1; + unsigned int n = *obj; + while (n) { + n &= (n-1); + _count++; + } + unsigned int b = *obj; + checkBit = 1; + vk_json_printf(_OUT, "\""); + if (*obj == 0) vk_json_printf(_OUT, "0"); + for (unsigned int i = 0, bitCount = 0; i < max_bits; i++, checkBit <<= 1) { + unsigned int res = b & checkBit; + if (res) { + bitCount++; + if (bitCount < _count) { + vk_json_printf(_OUT, "%s | ", VkSwapchainCreateFlagBitsKHR_map(1<sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkSwapchainCreateFlagsKHR(&obj->flags, "flags", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"surface\" : \"\",\n"); + + print_uint32_t(&obj->minImageCount, "minImageCount", 1); + + print_VkFormat(&obj->imageFormat, "imageFormat", 1); + + print_VkColorSpaceKHR(&obj->imageColorSpace, "imageColorSpace", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"imageExtent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->imageExtent, "imageExtent", 1); + } + + print_uint32_t(&obj->imageArrayLayers, "imageArrayLayers", 1); + + print_VkImageUsageFlags(&obj->imageUsage, "imageUsage", 1); + + print_VkSharingMode(&obj->imageSharingMode, "imageSharingMode", 1); + + print_uint32_t(&obj->queueFamilyIndexCount, "queueFamilyIndexCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pQueueFamilyIndices\" :"); + if (obj->pQueueFamilyIndices) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->queueFamilyIndexCount); i++) { + char tmp[100]; + sprintf(tmp, "pQueueFamilyIndices_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->queueFamilyIndexCount); + print_uint32_t(&obj->pQueueFamilyIndices[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_VkSurfaceTransformFlagBitsKHR(&obj->preTransform, "preTransform", 1); + + print_VkCompositeAlphaFlagBitsKHR(&obj->compositeAlpha, "compositeAlpha", 1); + + print_VkPresentModeKHR(&obj->presentMode, "presentMode", 1); + + print_VkBool32(&obj->clipped, "clipped", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"oldSwapchain\" : \"\"\n"); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_swapchain +void print_VkPresentInfoKHR(const VkPresentInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->waitSemaphoreCount, "waitSemaphoreCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pWaitSemaphores\" :"); + if (obj->pWaitSemaphores) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->waitSemaphoreCount); i++) { + char tmp[100]; + sprintf(tmp, "pWaitSemaphores_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->waitSemaphoreCount); + print_VkSemaphore(&obj->pWaitSemaphores[i], tmp, isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->swapchainCount, "swapchainCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pSwapchains\" :"); + if (obj->pSwapchains) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->swapchainCount); i++) { + char tmp[100]; + sprintf(tmp, "pSwapchains_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->swapchainCount); + print_VkSwapchainKHR(&obj->pSwapchains[i], tmp, isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pImageIndices\" :"); + if (obj->pImageIndices) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->swapchainCount); i++) { + char tmp[100]; + sprintf(tmp, "pImageIndices_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->swapchainCount); + print_uint32_t(&obj->pImageIndices[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pResults\" :"); + if (obj->pResults) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->swapchainCount); i++) { + char tmp[100]; + sprintf(tmp, "pResults_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->swapchainCount); + print_VkResult(&obj->pResults[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_swapchain +void print_VkImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"swapchain\" : \"\"\n"); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_swapchain +void print_VkBindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"swapchain\" : \"\",\n"); + + print_uint32_t(&obj->imageIndex, "imageIndex", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_swapchain +void print_VkAcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"swapchain\" : \"\",\n"); + + print_uint64_t(&obj->timeout, "timeout", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"semaphore\" : \"\",\n"); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"fence\" : \"\",\n"); + + print_uint32_t(&obj->deviceMask, "deviceMask", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_swapchain +void print_VkDeviceGroupPresentCapabilitiesKHR(const VkDeviceGroupPresentCapabilitiesKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"presentMask\" :"); + if (obj->presentMask) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_MAX_DEVICE_GROUP_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "presentMask_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_MAX_DEVICE_GROUP_SIZE); + print_uint32_t(&obj->presentMask[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_VkDeviceGroupPresentModeFlagsKHR(&obj->modes, "modes", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_swapchain +void print_VkDeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->swapchainCount, "swapchainCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pDeviceMasks\" :"); + if (obj->pDeviceMasks) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->swapchainCount); i++) { + char tmp[100]; + sprintf(tmp, "pDeviceMasks_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->swapchainCount); + print_uint32_t(&obj->pDeviceMasks[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_VkDeviceGroupPresentModeFlagBitsKHR(&obj->mode, "mode", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_swapchain +void print_VkDeviceGroupSwapchainCreateInfoKHR(const VkDeviceGroupSwapchainCreateInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDeviceGroupPresentModeFlagsKHR(&obj->modes, "modes", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_display +void print_VkDisplayKHR(const VkDisplayKHR * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_display +void print_VkDisplayModeKHR(const VkDisplayModeKHR * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_display +static const char* VkDisplayPlaneAlphaFlagBitsKHR_map(int o) { +switch (o) { + case (1 << 0): return "VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR"; + case (1 << 1): return "VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR"; + case (1 << 2): return "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR"; + case (1 << 3): return "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR"; + } + return NULL; +} +void print_VkDisplayPlaneAlphaFlagBitsKHR(const VkDisplayPlaneAlphaFlagBitsKHR* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkDisplayPlaneAlphaFlagBitsKHR_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_display +void print_VkDisplayModeCreateFlagsKHR(const VkDisplayModeCreateFlagsKHR * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : \"%d\"%s\n", str, (int)(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_display +void print_VkDisplayPlaneAlphaFlagsKHR(const VkDisplayPlaneAlphaFlagsKHR * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : ", str); + const unsigned int max_bits = 64; + unsigned int _count = 0; + unsigned int checkBit = 1; + unsigned int n = *obj; + while (n) { + n &= (n-1); + _count++; + } + unsigned int b = *obj; + checkBit = 1; + vk_json_printf(_OUT, "\""); + if (*obj == 0) vk_json_printf(_OUT, "0"); + for (unsigned int i = 0, bitCount = 0; i < max_bits; i++, checkBit <<= 1) { + unsigned int res = b & checkBit; + if (res) { + bitCount++; + if (bitCount < _count) { + vk_json_printf(_OUT, "%s | ", VkDisplayPlaneAlphaFlagBitsKHR_map(1<visibleRegion, "visibleRegion", 1); + } + + print_uint32_t(&obj->refreshRate, "refreshRate", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_display +void print_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDisplayModeCreateFlagsKHR(&obj->flags, "flags", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"parameters\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkDisplayModeParametersKHR(&obj->parameters, "parameters", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_display +void print_VkDisplayModePropertiesKHR(const VkDisplayModePropertiesKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"displayMode\" : \"\",\n"); + + PRINT_SPACE + vk_json_printf(_OUT, "\"parameters\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkDisplayModeParametersKHR(&obj->parameters, "parameters", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_display +void print_VkDisplayPlaneCapabilitiesKHR(const VkDisplayPlaneCapabilitiesKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkDisplayPlaneAlphaFlagsKHR(&obj->supportedAlpha, "supportedAlpha", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"minSrcPosition\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkOffset2D(&obj->minSrcPosition, "minSrcPosition", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"maxSrcPosition\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkOffset2D(&obj->maxSrcPosition, "maxSrcPosition", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"minSrcExtent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->minSrcExtent, "minSrcExtent", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"maxSrcExtent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->maxSrcExtent, "maxSrcExtent", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"minDstPosition\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkOffset2D(&obj->minDstPosition, "minDstPosition", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"maxDstPosition\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkOffset2D(&obj->maxDstPosition, "maxDstPosition", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"minDstExtent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->minDstExtent, "minDstExtent", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"maxDstExtent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->maxDstExtent, "maxDstExtent", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_display +void print_VkDisplayPlanePropertiesKHR(const VkDisplayPlanePropertiesKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"currentDisplay\" : \"\",\n"); + + print_uint32_t(&obj->currentStackIndex, "currentStackIndex", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_display +void print_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"display\" : \"\",\n"); + + /** Printing string inline. **/ + PRINT_SPACE + vk_json_printf(_OUT, "\"displayName\" : \"%s\",\n", (char*)obj->displayName); + + PRINT_SPACE + vk_json_printf(_OUT, "\"physicalDimensions\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->physicalDimensions, "physicalDimensions", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"physicalResolution\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->physicalResolution, "physicalResolution", 1); + } + + print_VkSurfaceTransformFlagsKHR(&obj->supportedTransforms, "supportedTransforms", 1); + + print_VkBool32(&obj->planeReorderPossible, "planeReorderPossible", 1); + + print_VkBool32(&obj->persistentContent, "persistentContent", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_display +void print_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDisplaySurfaceCreateFlagsKHR(&obj->flags, "flags", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"displayMode\" : \"\",\n"); + + print_uint32_t(&obj->planeIndex, "planeIndex", 1); + + print_uint32_t(&obj->planeStackIndex, "planeStackIndex", 1); + + print_VkSurfaceTransformFlagBitsKHR(&obj->transform, "transform", 1); + + print_float(&obj->globalAlpha, "globalAlpha", 1); + + print_VkDisplayPlaneAlphaFlagBitsKHR(&obj->alphaMode, "alphaMode", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"imageExtent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->imageExtent, "imageExtent", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_display_swapchain +void print_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"srcRect\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkRect2D(&obj->srcRect, "srcRect", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"dstRect\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkRect2D(&obj->dstRect, "dstRect", 1); + } + + print_VkBool32(&obj->persistent, "persistent", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_external_memory_fd +void print_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkExternalMemoryHandleTypeFlagBits(&obj->handleType, "handleType", 1); + + print_int(&obj->fd, "fd", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_external_memory_fd +void print_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->memoryTypeBits, "memoryTypeBits", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_external_memory_fd +void print_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"memory\" : \"\",\n"); + + print_VkExternalMemoryHandleTypeFlagBits(&obj->handleType, "handleType", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_external_semaphore_fd +void print_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"semaphore\" : \"\",\n"); + + print_VkSemaphoreImportFlags(&obj->flags, "flags", 1); + + print_VkExternalSemaphoreHandleTypeFlagBits(&obj->handleType, "handleType", 1); + + print_int(&obj->fd, "fd", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_external_semaphore_fd +void print_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"semaphore\" : \"\",\n"); + + print_VkExternalSemaphoreHandleTypeFlagBits(&obj->handleType, "handleType", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_incremental_present +void print_VkRectLayerKHR(const VkRectLayerKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + PRINT_SPACE + vk_json_printf(_OUT, "\"offset\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkOffset2D(&obj->offset, "offset", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"extent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->extent, "extent", 1); + } + + print_uint32_t(&obj->layer, "layer", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_incremental_present +void print_VkPresentRegionKHR(const VkPresentRegionKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint32_t(&obj->rectangleCount, "rectangleCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pRectangles\" :"); + if (obj->pRectangles) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->rectangleCount); i++) { + if (i+1 == *(&obj->rectangleCount)) + print_VkRectLayerKHR(&obj->pRectangles[i], "pRectangles", 0); + else + print_VkRectLayerKHR(&obj->pRectangles[i], "pRectangles", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_incremental_present +void print_VkPresentRegionsKHR(const VkPresentRegionsKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->swapchainCount, "swapchainCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pRegions\" :"); + if (obj->pRegions) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->swapchainCount); i++) { + if (i+1 == *(&obj->swapchainCount)) + print_VkPresentRegionKHR(&obj->pRegions[i], "pRegions", 0); + else + print_VkPresentRegionKHR(&obj->pRegions[i], "pRegions", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_shared_presentable_image +void print_VkSharedPresentSurfaceCapabilitiesKHR(const VkSharedPresentSurfaceCapabilitiesKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkImageUsageFlags(&obj->sharedPresentSupportedUsageFlags, "sharedPresentSupportedUsageFlags", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_external_fence_fd +void print_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"fence\" : \"\",\n"); + + print_VkFenceImportFlags(&obj->flags, "flags", 1); + + print_VkExternalFenceHandleTypeFlagBits(&obj->handleType, "handleType", 1); + + print_int(&obj->fd, "fd", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_external_fence_fd +void print_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"fence\" : \"\",\n"); + + print_VkExternalFenceHandleTypeFlagBits(&obj->handleType, "handleType", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_performance_query +static const char* VkPerformanceCounterUnitKHR_map(int o) { +switch (o) { + case 0: return "VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR"; + case 1: return "VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR"; + case 2: return "VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR"; + case 3: return "VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR"; + case 4: return "VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR"; + case 5: return "VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR"; + case 6: return "VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR"; + case 7: return "VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR"; + case 8: return "VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR"; + case 9: return "VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR"; + case 10: return "VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR"; + } + return NULL; +} +void print_VkPerformanceCounterUnitKHR(const VkPerformanceCounterUnitKHR* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkPerformanceCounterUnitKHR_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_performance_query +static const char* VkPerformanceCounterScopeKHR_map(int o) { +switch (o) { + case 0: return "VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR"; + case 1: return "VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR"; + case 2: return "VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR"; + } + return NULL; +} +void print_VkPerformanceCounterScopeKHR(const VkPerformanceCounterScopeKHR* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkPerformanceCounterScopeKHR_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_performance_query +static const char* VkPerformanceCounterStorageKHR_map(int o) { +switch (o) { + case 0: return "VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR"; + case 1: return "VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR"; + case 2: return "VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR"; + case 3: return "VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR"; + case 4: return "VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR"; + case 5: return "VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR"; + } + return NULL; +} +void print_VkPerformanceCounterStorageKHR(const VkPerformanceCounterStorageKHR* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkPerformanceCounterStorageKHR_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_performance_query +static const char* VkPerformanceCounterDescriptionFlagBitsKHR_map(int o) { +switch (o) { + case (1 << 0): return "VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR"; + case (1 << 1): return "VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR"; + } + return NULL; +} +void print_VkPerformanceCounterDescriptionFlagBitsKHR(const VkPerformanceCounterDescriptionFlagBitsKHR* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkPerformanceCounterDescriptionFlagBitsKHR_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_performance_query +static const char* VkAcquireProfilingLockFlagBitsKHR_map(int o) { +switch (o) { + } + return NULL; +} +void print_VkAcquireProfilingLockFlagBitsKHR(const VkAcquireProfilingLockFlagBitsKHR* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkAcquireProfilingLockFlagBitsKHR_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_performance_query +void print_VkPerformanceCounterDescriptionFlagsKHR(const VkPerformanceCounterDescriptionFlagsKHR * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : ", str); + const unsigned int max_bits = 64; + unsigned int _count = 0; + unsigned int checkBit = 1; + unsigned int n = *obj; + while (n) { + n &= (n-1); + _count++; + } + unsigned int b = *obj; + checkBit = 1; + vk_json_printf(_OUT, "\""); + if (*obj == 0) vk_json_printf(_OUT, "0"); + for (unsigned int i = 0, bitCount = 0; i < max_bits; i++, checkBit <<= 1) { + unsigned int res = b & checkBit; + if (res) { + bitCount++; + if (bitCount < _count) { + vk_json_printf(_OUT, "%s | ", VkPerformanceCounterDescriptionFlagBitsKHR_map(1<sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->performanceCounterQueryPools, "performanceCounterQueryPools", 1); + + print_VkBool32(&obj->performanceCounterMultipleQueryPools, "performanceCounterMultipleQueryPools", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_performance_query +void print_VkPhysicalDevicePerformanceQueryPropertiesKHR(const VkPhysicalDevicePerformanceQueryPropertiesKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->allowCommandBufferQueryCopies, "allowCommandBufferQueryCopies", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_performance_query +void print_VkPerformanceCounterKHR(const VkPerformanceCounterKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPerformanceCounterUnitKHR(&obj->unit, "unit", 1); + + print_VkPerformanceCounterScopeKHR(&obj->scope, "scope", 1); + + print_VkPerformanceCounterStorageKHR(&obj->storage, "storage", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"uuid\" :"); + if (obj->uuid) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_UUID_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "uuid_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_UUID_SIZE); + print_uint8_t(&obj->uuid[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_performance_query +void print_VkPerformanceCounterDescriptionKHR(const VkPerformanceCounterDescriptionKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPerformanceCounterDescriptionFlagsKHR(&obj->flags, "flags", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"name\" :"); + if (obj->name) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_MAX_DESCRIPTION_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "name_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_MAX_DESCRIPTION_SIZE); + print_char(&obj->name[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"category\" :"); + if (obj->category) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_MAX_DESCRIPTION_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "category_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_MAX_DESCRIPTION_SIZE); + print_char(&obj->category[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"description\" :"); + if (obj->description) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_MAX_DESCRIPTION_SIZE); i++) { + char tmp[100]; + sprintf(tmp, "description_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_MAX_DESCRIPTION_SIZE); + print_char(&obj->description[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_performance_query +void print_VkQueryPoolPerformanceCreateInfoKHR(const VkQueryPoolPerformanceCreateInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->queueFamilyIndex, "queueFamilyIndex", 1); + + print_uint32_t(&obj->counterIndexCount, "counterIndexCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pCounterIndices\" :"); + if (obj->pCounterIndices) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->counterIndexCount); i++) { + char tmp[100]; + sprintf(tmp, "pCounterIndices_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->counterIndexCount); + print_uint32_t(&obj->pCounterIndices[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_performance_query +void print_VkPerformanceCounterResultKHR(const VkPerformanceCounterResultKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_int32_t(&obj->int32, "int32", 1); + + print_int64_t(&obj->int64, "int64", 1); + + print_uint32_t(&obj->uint32, "uint32", 1); + + print_uint64_t(&obj->uint64, "uint64", 1); + + print_float(&obj->float32, "float32", 1); + + print_double(&obj->float64, "float64", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_performance_query +void print_VkAcquireProfilingLockInfoKHR(const VkAcquireProfilingLockInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkAcquireProfilingLockFlagsKHR(&obj->flags, "flags", 1); + + print_uint64_t(&obj->timeout, "timeout", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_performance_query +void print_VkPerformanceQuerySubmitInfoKHR(const VkPerformanceQuerySubmitInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->counterPassIndex, "counterPassIndex", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_performance_query +void print_VkPerformanceQueryReservationInfoKHR(const VkPerformanceQueryReservationInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->maxPerformanceQueriesPerPool, "maxPerformanceQueriesPerPool", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_get_surface_capabilities2 +void print_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"surface\" : \"\"\n"); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_get_surface_capabilities2 +void print_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"surfaceCapabilities\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkSurfaceCapabilitiesKHR(&obj->surfaceCapabilities, "surfaceCapabilities", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_get_surface_capabilities2 +void print_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"surfaceFormat\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkSurfaceFormatKHR(&obj->surfaceFormat, "surfaceFormat", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_get_display_properties2 +void print_VkDisplayProperties2KHR(const VkDisplayProperties2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"displayProperties\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkDisplayPropertiesKHR(&obj->displayProperties, "displayProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_get_display_properties2 +void print_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"displayPlaneProperties\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkDisplayPlanePropertiesKHR(&obj->displayPlaneProperties, "displayPlaneProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_get_display_properties2 +void print_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"displayModeProperties\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkDisplayModePropertiesKHR(&obj->displayModeProperties, "displayModeProperties", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_get_display_properties2 +void print_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"mode\" : \"\",\n"); + + print_uint32_t(&obj->planeIndex, "planeIndex", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_get_display_properties2 +void print_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"capabilities\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkDisplayPlaneCapabilitiesKHR(&obj->capabilities, "capabilities", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_shader_clock +void print_VkPhysicalDeviceShaderClockFeaturesKHR(const VkPhysicalDeviceShaderClockFeaturesKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->shaderSubgroupClock, "shaderSubgroupClock", 1); + + print_VkBool32(&obj->shaderDeviceClock, "shaderDeviceClock", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_shader_terminate_invocation +void print_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->shaderTerminateInvocation, "shaderTerminateInvocation", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_fragment_shading_rate +static const char* VkFragmentShadingRateCombinerOpKHR_map(int o) { +switch (o) { + case 0: return "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR"; + case 1: return "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR"; + case 2: return "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR"; + case 3: return "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR"; + case 4: return "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR"; + } + return NULL; +} +void print_VkFragmentShadingRateCombinerOpKHR(const VkFragmentShadingRateCombinerOpKHR* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkFragmentShadingRateCombinerOpKHR_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_fragment_shading_rate +void print_VkFragmentShadingRateAttachmentInfoKHR(const VkFragmentShadingRateAttachmentInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"pFragmentShadingRateAttachment\" :"); + if (obj->pFragmentShadingRateAttachment) { + vk_json_printf(_OUT, "\n"); + print_VkAttachmentReference2(*(&obj->pFragmentShadingRateAttachment), "pFragmentShadingRateAttachment", 1); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"shadingRateAttachmentTexelSize\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->shadingRateAttachmentTexelSize, "shadingRateAttachmentTexelSize", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_fragment_shading_rate +void print_VkPipelineFragmentShadingRateStateCreateInfoKHR(const VkPipelineFragmentShadingRateStateCreateInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"fragmentSize\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->fragmentSize, "fragmentSize", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"combinerOps\" :"); + if (obj->combinerOps) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (2); i++) { + char tmp[100]; + sprintf(tmp, "combinerOps_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (2); + print_VkFragmentShadingRateCombinerOpKHR(&obj->combinerOps[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_fragment_shading_rate +void print_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->pipelineFragmentShadingRate, "pipelineFragmentShadingRate", 1); + + print_VkBool32(&obj->primitiveFragmentShadingRate, "primitiveFragmentShadingRate", 1); + + print_VkBool32(&obj->attachmentFragmentShadingRate, "attachmentFragmentShadingRate", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_fragment_shading_rate +void print_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"minFragmentShadingRateAttachmentTexelSize\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->minFragmentShadingRateAttachmentTexelSize, "minFragmentShadingRateAttachmentTexelSize", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"maxFragmentShadingRateAttachmentTexelSize\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->maxFragmentShadingRateAttachmentTexelSize, "maxFragmentShadingRateAttachmentTexelSize", 1); + } + + print_uint32_t(&obj->maxFragmentShadingRateAttachmentTexelSizeAspectRatio, "maxFragmentShadingRateAttachmentTexelSizeAspectRatio", 1); + + print_VkBool32(&obj->primitiveFragmentShadingRateWithMultipleViewports, "primitiveFragmentShadingRateWithMultipleViewports", 1); + + print_VkBool32(&obj->layeredShadingRateAttachments, "layeredShadingRateAttachments", 1); + + print_VkBool32(&obj->fragmentShadingRateNonTrivialCombinerOps, "fragmentShadingRateNonTrivialCombinerOps", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"maxFragmentSize\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->maxFragmentSize, "maxFragmentSize", 1); + } + + print_uint32_t(&obj->maxFragmentSizeAspectRatio, "maxFragmentSizeAspectRatio", 1); + + print_uint32_t(&obj->maxFragmentShadingRateCoverageSamples, "maxFragmentShadingRateCoverageSamples", 1); + + print_VkSampleCountFlagBits(&obj->maxFragmentShadingRateRasterizationSamples, "maxFragmentShadingRateRasterizationSamples", 1); + + print_VkBool32(&obj->fragmentShadingRateWithShaderDepthStencilWrites, "fragmentShadingRateWithShaderDepthStencilWrites", 1); + + print_VkBool32(&obj->fragmentShadingRateWithSampleMask, "fragmentShadingRateWithSampleMask", 1); + + print_VkBool32(&obj->fragmentShadingRateWithShaderSampleMask, "fragmentShadingRateWithShaderSampleMask", 1); + + print_VkBool32(&obj->fragmentShadingRateWithConservativeRasterization, "fragmentShadingRateWithConservativeRasterization", 1); + + print_VkBool32(&obj->fragmentShadingRateWithFragmentShaderInterlock, "fragmentShadingRateWithFragmentShaderInterlock", 1); + + print_VkBool32(&obj->fragmentShadingRateWithCustomSampleLocations, "fragmentShadingRateWithCustomSampleLocations", 1); + + print_VkBool32(&obj->fragmentShadingRateStrictMultiplyCombiner, "fragmentShadingRateStrictMultiplyCombiner", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_fragment_shading_rate +void print_VkPhysicalDeviceFragmentShadingRateKHR(const VkPhysicalDeviceFragmentShadingRateKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkSampleCountFlags(&obj->sampleCounts, "sampleCounts", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"fragmentSize\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->fragmentSize, "fragmentSize", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_object_refresh +static const char* VkRefreshObjectFlagBitsKHR_map(int o) { +switch (o) { + } + return NULL; +} +void print_VkRefreshObjectFlagBitsKHR(const VkRefreshObjectFlagBitsKHR* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkRefreshObjectFlagBitsKHR_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_object_refresh +void print_VkRefreshObjectFlagsKHR(const VkRefreshObjectFlagsKHR * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : ", str); + const unsigned int max_bits = 64; + unsigned int _count = 0; + unsigned int checkBit = 1; + unsigned int n = *obj; + while (n) { + n &= (n-1); + _count++; + } + unsigned int b = *obj; + checkBit = 1; + vk_json_printf(_OUT, "\""); + if (*obj == 0) vk_json_printf(_OUT, "0"); + for (unsigned int i = 0, bitCount = 0; i < max_bits; i++, checkBit <<= 1) { + unsigned int res = b & checkBit; + if (res) { + bitCount++; + if (bitCount < _count) { + vk_json_printf(_OUT, "%s | ", VkRefreshObjectFlagBitsKHR_map(1<objectType, "objectType", 1); + + print_uint64_t(&obj->objectHandle, "objectHandle", 1); + + print_VkRefreshObjectFlagsKHR(&obj->flags, "flags", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_object_refresh +void print_VkRefreshObjectListKHR(const VkRefreshObjectListKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->objectCount, "objectCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pObjects\" :"); + if (obj->pObjects) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->objectCount); i++) { + if (i+1 == *(&obj->objectCount)) + print_VkRefreshObjectKHR(&obj->pObjects[i], "pObjects", 0); + else + print_VkRefreshObjectKHR(&obj->pObjects[i], "pObjects", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_synchronization2 +void print_VkFlags64(const VkFlags64 * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : \"%" PRIu64 "\"%s\n", str, *obj, commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_synchronization2 +static const char* VkPipelineStageFlagBits2KHR_map(int o) { +switch (o) { + case 0: return "VK_PIPELINE_STAGE_2_NONE_KHR"; + case (1 << 0): return "VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR"; + case (1 << 1): return "VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR"; + case (1 << 2): return "VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR"; + case (1 << 3): return "VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR"; + case (1 << 4): return "VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR"; + case (1 << 5): return "VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR"; + case (1 << 6): return "VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR"; + case (1 << 7): return "VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR"; + case (1 << 8): return "VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR"; + case (1 << 9): return "VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR"; + case (1 << 10): return "VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR"; + case (1 << 11): return "VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR"; + case (1 << 12): return "VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR"; + case (1 << 13): return "VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR"; + case (1 << 14): return "VK_PIPELINE_STAGE_2_HOST_BIT_KHR"; + case (1 << 15): return "VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR"; + case (1 << 16): return "VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR"; + case (1 << 32): return "VK_PIPELINE_STAGE_2_COPY_BIT_KHR"; + case (1 << 33): return "VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR"; + case (1 << 34): return "VK_PIPELINE_STAGE_2_BLIT_BIT_KHR"; + case (1 << 35): return "VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR"; + case (1 << 36): return "VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR"; + case (1 << 37): return "VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR"; + case (1 << 38): return "VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR"; + case (1 << 26): return "VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR"; + case (1 << 27): return "VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR"; + case (1 << 24): return "VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT"; + case (1 << 18): return "VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT"; + case (1 << 17): return "VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV"; + case (1 << 22): return "VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; + case (1 << 25): return "VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR"; + case (1 << 21): return "VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR"; + case (1 << 23): return "VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT"; + case (1 << 19): return "VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV"; + case (1 << 20): return "VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV"; + case (1 << 39): return "VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI"; + case (1 << 40): return "VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI"; + case (1 << 28): return "VK_PIPELINE_STAGE_2_RESERVED_387_BIT_KHR"; + } + return NULL; +} +void print_VkPipelineStageFlagBits2KHR(const VkPipelineStageFlagBits2KHR* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkPipelineStageFlagBits2KHR_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_synchronization2 +static const char* VkAccessFlagBits2KHR_map(int o) { +switch (o) { + case 0: return "VK_ACCESS_2_NONE_KHR"; + case (1 << 0): return "VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR"; + case (1 << 1): return "VK_ACCESS_2_INDEX_READ_BIT_KHR"; + case (1 << 2): return "VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR"; + case (1 << 3): return "VK_ACCESS_2_UNIFORM_READ_BIT_KHR"; + case (1 << 4): return "VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR"; + case (1 << 5): return "VK_ACCESS_2_SHADER_READ_BIT_KHR"; + case (1 << 6): return "VK_ACCESS_2_SHADER_WRITE_BIT_KHR"; + case (1 << 7): return "VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR"; + case (1 << 8): return "VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR"; + case (1 << 9): return "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR"; + case (1 << 10): return "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR"; + case (1 << 11): return "VK_ACCESS_2_TRANSFER_READ_BIT_KHR"; + case (1 << 12): return "VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR"; + case (1 << 13): return "VK_ACCESS_2_HOST_READ_BIT_KHR"; + case (1 << 14): return "VK_ACCESS_2_HOST_WRITE_BIT_KHR"; + case (1 << 15): return "VK_ACCESS_2_MEMORY_READ_BIT_KHR"; + case (1 << 16): return "VK_ACCESS_2_MEMORY_WRITE_BIT_KHR"; + case (1 << 32): return "VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR"; + case (1 << 33): return "VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR"; + case (1 << 34): return "VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR"; + case (1 << 35): return "VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR"; + case (1 << 36): return "VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR"; + case (1 << 37): return "VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR"; + case (1 << 38): return "VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR"; + case (1 << 25): return "VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT"; + case (1 << 26): return "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT"; + case (1 << 27): return "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT"; + case (1 << 20): return "VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT"; + case (1 << 17): return "VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV"; + case (1 << 18): return "VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV"; + case (1 << 23): return "VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR"; + case (1 << 21): return "VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR"; + case (1 << 22): return "VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR"; + case (1 << 24): return "VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT"; + case (1 << 19): return "VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT"; + case (1 << 41): return "VK_ACCESS_2_RESERVED_41_BIT_AMD"; + case (1 << 39): return "VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI"; + case (1 << 40): return "VK_ACCESS_2_RESERVED_387_BIT_KHR"; + } + return NULL; +} +void print_VkAccessFlagBits2KHR(const VkAccessFlagBits2KHR* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkAccessFlagBits2KHR_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_synchronization2 +static const char* VkSubmitFlagBitsKHR_map(int o) { +switch (o) { + case (1 << 0): return "VK_SUBMIT_PROTECTED_BIT_KHR"; + } + return NULL; +} +void print_VkSubmitFlagBitsKHR(const VkSubmitFlagBitsKHR* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkSubmitFlagBitsKHR_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_synchronization2 +void print_VkPipelineStageFlags2KHR(const VkPipelineStageFlags2KHR * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : \"%d\"%s\n", str, (int)(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_synchronization2 +void print_VkAccessFlags2KHR(const VkAccessFlags2KHR * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : \"%d\"%s\n", str, (int)(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_synchronization2 +void print_VkSubmitFlagsKHR(const VkSubmitFlagsKHR * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : ", str); + const unsigned int max_bits = 64; + unsigned int _count = 0; + unsigned int checkBit = 1; + unsigned int n = *obj; + while (n) { + n &= (n-1); + _count++; + } + unsigned int b = *obj; + checkBit = 1; + vk_json_printf(_OUT, "\""); + if (*obj == 0) vk_json_printf(_OUT, "0"); + for (unsigned int i = 0, bitCount = 0; i < max_bits; i++, checkBit <<= 1) { + unsigned int res = b & checkBit; + if (res) { + bitCount++; + if (bitCount < _count) { + vk_json_printf(_OUT, "%s | ", VkSubmitFlagBitsKHR_map(1<sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineStageFlags2KHR(&obj->srcStageMask, "srcStageMask", 1); + + print_VkAccessFlags2KHR(&obj->srcAccessMask, "srcAccessMask", 1); + + print_VkPipelineStageFlags2KHR(&obj->dstStageMask, "dstStageMask", 1); + + print_VkAccessFlags2KHR(&obj->dstAccessMask, "dstAccessMask", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_synchronization2 +void print_VkBufferMemoryBarrier2KHR(const VkBufferMemoryBarrier2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineStageFlags2KHR(&obj->srcStageMask, "srcStageMask", 1); + + print_VkAccessFlags2KHR(&obj->srcAccessMask, "srcAccessMask", 1); + + print_VkPipelineStageFlags2KHR(&obj->dstStageMask, "dstStageMask", 1); + + print_VkAccessFlags2KHR(&obj->dstAccessMask, "dstAccessMask", 1); + + print_uint32_t(&obj->srcQueueFamilyIndex, "srcQueueFamilyIndex", 1); + + print_uint32_t(&obj->dstQueueFamilyIndex, "dstQueueFamilyIndex", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"buffer\" : \"\",\n"); + + print_VkDeviceSize(&obj->offset, "offset", 1); + + print_VkDeviceSize(&obj->size, "size", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_synchronization2 +void print_VkImageMemoryBarrier2KHR(const VkImageMemoryBarrier2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineStageFlags2KHR(&obj->srcStageMask, "srcStageMask", 1); + + print_VkAccessFlags2KHR(&obj->srcAccessMask, "srcAccessMask", 1); + + print_VkPipelineStageFlags2KHR(&obj->dstStageMask, "dstStageMask", 1); + + print_VkAccessFlags2KHR(&obj->dstAccessMask, "dstAccessMask", 1); + + print_VkImageLayout(&obj->oldLayout, "oldLayout", 1); + + print_VkImageLayout(&obj->newLayout, "newLayout", 1); + + print_uint32_t(&obj->srcQueueFamilyIndex, "srcQueueFamilyIndex", 1); + + print_uint32_t(&obj->dstQueueFamilyIndex, "dstQueueFamilyIndex", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"image\" : \"\",\n"); + + PRINT_SPACE + vk_json_printf(_OUT, "\"subresourceRange\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkImageSubresourceRange(&obj->subresourceRange, "subresourceRange", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_synchronization2 +void print_VkDependencyInfoKHR(const VkDependencyInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDependencyFlags(&obj->dependencyFlags, "dependencyFlags", 1); + + print_uint32_t(&obj->memoryBarrierCount, "memoryBarrierCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pMemoryBarriers\" :"); + if (obj->pMemoryBarriers) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->memoryBarrierCount); i++) { + if (i+1 == *(&obj->memoryBarrierCount)) + print_VkMemoryBarrier2KHR(&obj->pMemoryBarriers[i], "pMemoryBarriers", 0); + else + print_VkMemoryBarrier2KHR(&obj->pMemoryBarriers[i], "pMemoryBarriers", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->bufferMemoryBarrierCount, "bufferMemoryBarrierCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pBufferMemoryBarriers\" :"); + if (obj->pBufferMemoryBarriers) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->bufferMemoryBarrierCount); i++) { + if (i+1 == *(&obj->bufferMemoryBarrierCount)) + print_VkBufferMemoryBarrier2KHR(&obj->pBufferMemoryBarriers[i], "pBufferMemoryBarriers", 0); + else + print_VkBufferMemoryBarrier2KHR(&obj->pBufferMemoryBarriers[i], "pBufferMemoryBarriers", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->imageMemoryBarrierCount, "imageMemoryBarrierCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pImageMemoryBarriers\" :"); + if (obj->pImageMemoryBarriers) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->imageMemoryBarrierCount); i++) { + if (i+1 == *(&obj->imageMemoryBarrierCount)) + print_VkImageMemoryBarrier2KHR(&obj->pImageMemoryBarriers[i], "pImageMemoryBarriers", 0); + else + print_VkImageMemoryBarrier2KHR(&obj->pImageMemoryBarriers[i], "pImageMemoryBarriers", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_synchronization2 +void print_VkSemaphoreSubmitInfoKHR(const VkSemaphoreSubmitInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"semaphore\" : \"\",\n"); + + print_uint64_t(&obj->value, "value", 1); + + print_VkPipelineStageFlags2KHR(&obj->stageMask, "stageMask", 1); + + print_uint32_t(&obj->deviceIndex, "deviceIndex", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_synchronization2 +void print_VkCommandBufferSubmitInfoKHR(const VkCommandBufferSubmitInfoKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"commandBuffer\" : \"\",\n"); + + print_uint32_t(&obj->deviceMask, "deviceMask", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_synchronization2 +void print_VkSubmitInfo2KHR(const VkSubmitInfo2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkSubmitFlagsKHR(&obj->flags, "flags", 1); + + print_uint32_t(&obj->waitSemaphoreInfoCount, "waitSemaphoreInfoCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pWaitSemaphoreInfos\" :"); + if (obj->pWaitSemaphoreInfos) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->waitSemaphoreInfoCount); i++) { + if (i+1 == *(&obj->waitSemaphoreInfoCount)) + print_VkSemaphoreSubmitInfoKHR(&obj->pWaitSemaphoreInfos[i], "pWaitSemaphoreInfos", 0); + else + print_VkSemaphoreSubmitInfoKHR(&obj->pWaitSemaphoreInfos[i], "pWaitSemaphoreInfos", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->commandBufferInfoCount, "commandBufferInfoCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pCommandBufferInfos\" :"); + if (obj->pCommandBufferInfos) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->commandBufferInfoCount); i++) { + if (i+1 == *(&obj->commandBufferInfoCount)) + print_VkCommandBufferSubmitInfoKHR(&obj->pCommandBufferInfos[i], "pCommandBufferInfos", 0); + else + print_VkCommandBufferSubmitInfoKHR(&obj->pCommandBufferInfos[i], "pCommandBufferInfos", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->signalSemaphoreInfoCount, "signalSemaphoreInfoCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pSignalSemaphoreInfos\" :"); + if (obj->pSignalSemaphoreInfos) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->signalSemaphoreInfoCount); i++) { + if (i+1 == *(&obj->signalSemaphoreInfoCount)) + print_VkSemaphoreSubmitInfoKHR(&obj->pSignalSemaphoreInfos[i], "pSignalSemaphoreInfos", 0); + else + print_VkSemaphoreSubmitInfoKHR(&obj->pSignalSemaphoreInfos[i], "pSignalSemaphoreInfos", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_synchronization2 +void print_VkPhysicalDeviceSynchronization2FeaturesKHR(const VkPhysicalDeviceSynchronization2FeaturesKHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->synchronization2, "synchronization2", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_synchronization2 +void print_VkQueueFamilyCheckpointProperties2NV(const VkQueueFamilyCheckpointProperties2NV * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineStageFlags2KHR(&obj->checkpointExecutionStageMask, "checkpointExecutionStageMask", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_synchronization2 +void print_VkCheckpointData2NV(const VkCheckpointData2NV * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineStageFlags2KHR(&obj->stage, "stage", 1); + + /** Note: Ignoring void* data. **/ + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_copy_commands2 +void print_VkBufferCopy2KHR(const VkBufferCopy2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDeviceSize(&obj->srcOffset, "srcOffset", 1); + + print_VkDeviceSize(&obj->dstOffset, "dstOffset", 1); + + print_VkDeviceSize(&obj->size, "size", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_copy_commands2 +void print_VkCopyBufferInfo2KHR(const VkCopyBufferInfo2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"srcBuffer\" : \"\",\n"); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"dstBuffer\" : \"\",\n"); + + print_uint32_t(&obj->regionCount, "regionCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pRegions\" :"); + if (obj->pRegions) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->regionCount); i++) { + if (i+1 == *(&obj->regionCount)) + print_VkBufferCopy2KHR(&obj->pRegions[i], "pRegions", 0); + else + print_VkBufferCopy2KHR(&obj->pRegions[i], "pRegions", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_copy_commands2 +void print_VkImageCopy2KHR(const VkImageCopy2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"srcSubresource\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkImageSubresourceLayers(&obj->srcSubresource, "srcSubresource", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"srcOffset\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkOffset3D(&obj->srcOffset, "srcOffset", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"dstSubresource\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkImageSubresourceLayers(&obj->dstSubresource, "dstSubresource", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"dstOffset\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkOffset3D(&obj->dstOffset, "dstOffset", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"extent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent3D(&obj->extent, "extent", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_copy_commands2 +void print_VkCopyImageInfo2KHR(const VkCopyImageInfo2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"srcImage\" : \"\",\n"); + + print_VkImageLayout(&obj->srcImageLayout, "srcImageLayout", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"dstImage\" : \"\",\n"); + + print_VkImageLayout(&obj->dstImageLayout, "dstImageLayout", 1); + + print_uint32_t(&obj->regionCount, "regionCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pRegions\" :"); + if (obj->pRegions) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->regionCount); i++) { + if (i+1 == *(&obj->regionCount)) + print_VkImageCopy2KHR(&obj->pRegions[i], "pRegions", 0); + else + print_VkImageCopy2KHR(&obj->pRegions[i], "pRegions", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_copy_commands2 +void print_VkBufferImageCopy2KHR(const VkBufferImageCopy2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDeviceSize(&obj->bufferOffset, "bufferOffset", 1); + + print_uint32_t(&obj->bufferRowLength, "bufferRowLength", 1); + + print_uint32_t(&obj->bufferImageHeight, "bufferImageHeight", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"imageSubresource\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkImageSubresourceLayers(&obj->imageSubresource, "imageSubresource", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"imageOffset\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkOffset3D(&obj->imageOffset, "imageOffset", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"imageExtent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent3D(&obj->imageExtent, "imageExtent", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_copy_commands2 +void print_VkCopyBufferToImageInfo2KHR(const VkCopyBufferToImageInfo2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"srcBuffer\" : \"\",\n"); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"dstImage\" : \"\",\n"); + + print_VkImageLayout(&obj->dstImageLayout, "dstImageLayout", 1); + + print_uint32_t(&obj->regionCount, "regionCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pRegions\" :"); + if (obj->pRegions) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->regionCount); i++) { + if (i+1 == *(&obj->regionCount)) + print_VkBufferImageCopy2KHR(&obj->pRegions[i], "pRegions", 0); + else + print_VkBufferImageCopy2KHR(&obj->pRegions[i], "pRegions", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_copy_commands2 +void print_VkCopyImageToBufferInfo2KHR(const VkCopyImageToBufferInfo2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"srcImage\" : \"\",\n"); + + print_VkImageLayout(&obj->srcImageLayout, "srcImageLayout", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"dstBuffer\" : \"\",\n"); + + print_uint32_t(&obj->regionCount, "regionCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pRegions\" :"); + if (obj->pRegions) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->regionCount); i++) { + if (i+1 == *(&obj->regionCount)) + print_VkBufferImageCopy2KHR(&obj->pRegions[i], "pRegions", 0); + else + print_VkBufferImageCopy2KHR(&obj->pRegions[i], "pRegions", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_copy_commands2 +void print_VkImageBlit2KHR(const VkImageBlit2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"srcSubresource\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkImageSubresourceLayers(&obj->srcSubresource, "srcSubresource", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"srcOffsets\" :"); + if (obj->srcOffsets) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (2); i++) { + char tmp[100]; + sprintf(tmp, "srcOffsets_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (2); + print_VkOffset3D(&obj->srcOffsets[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"dstSubresource\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkImageSubresourceLayers(&obj->dstSubresource, "dstSubresource", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"dstOffsets\" :"); + if (obj->dstOffsets) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (2); i++) { + char tmp[100]; + sprintf(tmp, "dstOffsets_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (2); + print_VkOffset3D(&obj->dstOffsets[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_copy_commands2 +void print_VkBlitImageInfo2KHR(const VkBlitImageInfo2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"srcImage\" : \"\",\n"); + + print_VkImageLayout(&obj->srcImageLayout, "srcImageLayout", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"dstImage\" : \"\",\n"); + + print_VkImageLayout(&obj->dstImageLayout, "dstImageLayout", 1); + + print_uint32_t(&obj->regionCount, "regionCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pRegions\" :"); + if (obj->pRegions) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->regionCount); i++) { + if (i+1 == *(&obj->regionCount)) + print_VkImageBlit2KHR(&obj->pRegions[i], "pRegions", 0); + else + print_VkImageBlit2KHR(&obj->pRegions[i], "pRegions", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_VkFilter(&obj->filter, "filter", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_copy_commands2 +void print_VkImageResolve2KHR(const VkImageResolve2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"srcSubresource\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkImageSubresourceLayers(&obj->srcSubresource, "srcSubresource", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"srcOffset\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkOffset3D(&obj->srcOffset, "srcOffset", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"dstSubresource\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkImageSubresourceLayers(&obj->dstSubresource, "dstSubresource", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"dstOffset\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkOffset3D(&obj->dstOffset, "dstOffset", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"extent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent3D(&obj->extent, "extent", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_KHR_copy_commands2 +void print_VkResolveImageInfo2KHR(const VkResolveImageInfo2KHR * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"srcImage\" : \"\",\n"); + + print_VkImageLayout(&obj->srcImageLayout, "srcImageLayout", 1); + + /** Note: printing just an empty entry here **/ + PRINT_SPACE vk_json_printf(_OUT, "\"dstImage\" : \"\",\n"); + + print_VkImageLayout(&obj->dstImageLayout, "dstImageLayout", 1); + + print_uint32_t(&obj->regionCount, "regionCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pRegions\" :"); + if (obj->pRegions) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->regionCount); i++) { + if (i+1 == *(&obj->regionCount)) + print_VkImageResolve2KHR(&obj->pRegions[i], "pRegions", 0); + else + print_VkImageResolve2KHR(&obj->pRegions[i], "pRegions", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_texture_compression_astc_hdr +void print_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->textureCompressionASTC_HDR, "textureCompressionASTC_HDR", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_astc_decode_mode +void print_VkImageViewASTCDecodeModeEXT(const VkImageViewASTCDecodeModeEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkFormat(&obj->decodeMode, "decodeMode", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_astc_decode_mode +void print_VkPhysicalDeviceASTCDecodeFeaturesEXT(const VkPhysicalDeviceASTCDecodeFeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->decodeModeSharedExponent, "decodeModeSharedExponent", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_display_surface_counter +static const char* VkSurfaceCounterFlagBitsEXT_map(int o) { +switch (o) { + case (1 << 0): return "VK_SURFACE_COUNTER_VBLANK_BIT_EXT"; + } + return NULL; +} +void print_VkSurfaceCounterFlagBitsEXT(const VkSurfaceCounterFlagBitsEXT* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkSurfaceCounterFlagBitsEXT_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_display_surface_counter +void print_VkSurfaceCounterFlagsEXT(const VkSurfaceCounterFlagsEXT * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : ", str); + const unsigned int max_bits = 64; + unsigned int _count = 0; + unsigned int checkBit = 1; + unsigned int n = *obj; + while (n) { + n &= (n-1); + _count++; + } + unsigned int b = *obj; + checkBit = 1; + vk_json_printf(_OUT, "\""); + if (*obj == 0) vk_json_printf(_OUT, "0"); + for (unsigned int i = 0, bitCount = 0; i < max_bits; i++, checkBit <<= 1) { + unsigned int res = b & checkBit; + if (res) { + bitCount++; + if (bitCount < _count) { + vk_json_printf(_OUT, "%s | ", VkSurfaceCounterFlagBitsEXT_map(1<sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->minImageCount, "minImageCount", 1); + + print_uint32_t(&obj->maxImageCount, "maxImageCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"currentExtent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->currentExtent, "currentExtent", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"minImageExtent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->minImageExtent, "minImageExtent", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"maxImageExtent\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->maxImageExtent, "maxImageExtent", 1); + } + + print_uint32_t(&obj->maxImageArrayLayers, "maxImageArrayLayers", 1); + + print_VkSurfaceTransformFlagsKHR(&obj->supportedTransforms, "supportedTransforms", 1); + + print_VkSurfaceTransformFlagBitsKHR(&obj->currentTransform, "currentTransform", 1); + + print_VkCompositeAlphaFlagsKHR(&obj->supportedCompositeAlpha, "supportedCompositeAlpha", 1); + + print_VkImageUsageFlags(&obj->supportedUsageFlags, "supportedUsageFlags", 1); + + print_VkSurfaceCounterFlagsEXT(&obj->supportedSurfaceCounters, "supportedSurfaceCounters", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_display_control +static const char* VkDisplayPowerStateEXT_map(int o) { +switch (o) { + case 0: return "VK_DISPLAY_POWER_STATE_OFF_EXT"; + case 1: return "VK_DISPLAY_POWER_STATE_SUSPEND_EXT"; + case 2: return "VK_DISPLAY_POWER_STATE_ON_EXT"; + } + return NULL; +} +void print_VkDisplayPowerStateEXT(const VkDisplayPowerStateEXT* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkDisplayPowerStateEXT_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_display_control +static const char* VkDeviceEventTypeEXT_map(int o) { +switch (o) { + case 0: return "VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT"; + } + return NULL; +} +void print_VkDeviceEventTypeEXT(const VkDeviceEventTypeEXT* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkDeviceEventTypeEXT_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_display_control +static const char* VkDisplayEventTypeEXT_map(int o) { +switch (o) { + case 0: return "VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT"; + } + return NULL; +} +void print_VkDisplayEventTypeEXT(const VkDisplayEventTypeEXT* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkDisplayEventTypeEXT_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_display_control +void print_VkDisplayPowerInfoEXT(const VkDisplayPowerInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDisplayPowerStateEXT(&obj->powerState, "powerState", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_display_control +void print_VkDeviceEventInfoEXT(const VkDeviceEventInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDeviceEventTypeEXT(&obj->deviceEvent, "deviceEvent", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_display_control +void print_VkDisplayEventInfoEXT(const VkDisplayEventInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDisplayEventTypeEXT(&obj->displayEvent, "displayEvent", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_display_control +void print_VkSwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkSurfaceCounterFlagsEXT(&obj->surfaceCounters, "surfaceCounters", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_discard_rectangles +static const char* VkDiscardRectangleModeEXT_map(int o) { +switch (o) { + case 0: return "VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT"; + case 1: return "VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT"; + } + return NULL; +} +void print_VkDiscardRectangleModeEXT(const VkDiscardRectangleModeEXT* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkDiscardRectangleModeEXT_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_discard_rectangles +void print_VkPipelineDiscardRectangleStateCreateFlagsEXT(const VkPipelineDiscardRectangleStateCreateFlagsEXT * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : \"%d\"%s\n", str, (int)(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_discard_rectangles +void print_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const VkPhysicalDeviceDiscardRectanglePropertiesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->maxDiscardRectangles, "maxDiscardRectangles", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_discard_rectangles +void print_VkPipelineDiscardRectangleStateCreateInfoEXT(const VkPipelineDiscardRectangleStateCreateInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineDiscardRectangleStateCreateFlagsEXT(&obj->flags, "flags", 1); + + print_VkDiscardRectangleModeEXT(&obj->discardRectangleMode, "discardRectangleMode", 1); + + print_uint32_t(&obj->discardRectangleCount, "discardRectangleCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pDiscardRectangles\" :"); + if (obj->pDiscardRectangles) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->discardRectangleCount); i++) { + if (i+1 == *(&obj->discardRectangleCount)) + print_VkRect2D(&obj->pDiscardRectangles[i], "pDiscardRectangles", 0); + else + print_VkRect2D(&obj->pDiscardRectangles[i], "pDiscardRectangles", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_conservative_rasterization +static const char* VkConservativeRasterizationModeEXT_map(int o) { +switch (o) { + case 0: return "VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT"; + case 1: return "VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT"; + case 2: return "VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT"; + } + return NULL; +} +void print_VkConservativeRasterizationModeEXT(const VkConservativeRasterizationModeEXT* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkConservativeRasterizationModeEXT_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_conservative_rasterization +void print_VkPipelineRasterizationConservativeStateCreateFlagsEXT(const VkPipelineRasterizationConservativeStateCreateFlagsEXT * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : \"%d\"%s\n", str, (int)(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_conservative_rasterization +void print_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_float(&obj->primitiveOverestimationSize, "primitiveOverestimationSize", 1); + + print_float(&obj->maxExtraPrimitiveOverestimationSize, "maxExtraPrimitiveOverestimationSize", 1); + + print_float(&obj->extraPrimitiveOverestimationSizeGranularity, "extraPrimitiveOverestimationSizeGranularity", 1); + + print_VkBool32(&obj->primitiveUnderestimation, "primitiveUnderestimation", 1); + + print_VkBool32(&obj->conservativePointAndLineRasterization, "conservativePointAndLineRasterization", 1); + + print_VkBool32(&obj->degenerateTrianglesRasterized, "degenerateTrianglesRasterized", 1); + + print_VkBool32(&obj->degenerateLinesRasterized, "degenerateLinesRasterized", 1); + + print_VkBool32(&obj->fullyCoveredFragmentShaderInputVariable, "fullyCoveredFragmentShaderInputVariable", 1); + + print_VkBool32(&obj->conservativeRasterizationPostDepthCoverage, "conservativeRasterizationPostDepthCoverage", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_conservative_rasterization +void print_VkPipelineRasterizationConservativeStateCreateInfoEXT(const VkPipelineRasterizationConservativeStateCreateInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineRasterizationConservativeStateCreateFlagsEXT(&obj->flags, "flags", 1); + + print_VkConservativeRasterizationModeEXT(&obj->conservativeRasterizationMode, "conservativeRasterizationMode", 1); + + print_float(&obj->extraPrimitiveOverestimationSize, "extraPrimitiveOverestimationSize", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_depth_clip_enable +void print_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(const VkPipelineRasterizationDepthClipStateCreateFlagsEXT * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : \"%d\"%s\n", str, (int)(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_depth_clip_enable +void print_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const VkPhysicalDeviceDepthClipEnableFeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->depthClipEnable, "depthClipEnable", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_depth_clip_enable +void print_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const VkPipelineRasterizationDepthClipStateCreateInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(&obj->flags, "flags", 1); + + print_VkBool32(&obj->depthClipEnable, "depthClipEnable", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_hdr_metadata +void print_VkXYColorEXT(const VkXYColorEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_float(&obj->x, "x", 1); + + print_float(&obj->y, "y", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_hdr_metadata +void print_VkHdrMetadataEXT(const VkHdrMetadataEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"displayPrimaryRed\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkXYColorEXT(&obj->displayPrimaryRed, "displayPrimaryRed", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"displayPrimaryGreen\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkXYColorEXT(&obj->displayPrimaryGreen, "displayPrimaryGreen", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"displayPrimaryBlue\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkXYColorEXT(&obj->displayPrimaryBlue, "displayPrimaryBlue", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"whitePoint\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkXYColorEXT(&obj->whitePoint, "whitePoint", 1); + } + + print_float(&obj->maxLuminance, "maxLuminance", 1); + + print_float(&obj->minLuminance, "minLuminance", 1); + + print_float(&obj->maxContentLightLevel, "maxContentLightLevel", 1); + + print_float(&obj->maxFrameAverageLightLevel, "maxFrameAverageLightLevel", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_debug_utils +void print_VkDebugUtilsMessengerEXT(const VkDebugUtilsMessengerEXT * obj, const char* str, int commaNeeded) { + (void) * obj; + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\"%s\n", str, commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_debug_utils +static const char* VkDebugUtilsMessageSeverityFlagBitsEXT_map(int o) { +switch (o) { + case (1 << 0): return "VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT"; + case (1 << 4): return "VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT"; + case (1 << 8): return "VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT"; + case (1 << 12): return "VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT"; + } + return NULL; +} +void print_VkDebugUtilsMessageSeverityFlagBitsEXT(const VkDebugUtilsMessageSeverityFlagBitsEXT* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkDebugUtilsMessageSeverityFlagBitsEXT_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_debug_utils +static const char* VkDebugUtilsMessageTypeFlagBitsEXT_map(int o) { +switch (o) { + case (1 << 0): return "VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT"; + case (1 << 1): return "VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT"; + case (1 << 2): return "VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT"; + } + return NULL; +} +void print_VkDebugUtilsMessageTypeFlagBitsEXT(const VkDebugUtilsMessageTypeFlagBitsEXT* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkDebugUtilsMessageTypeFlagBitsEXT_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_debug_utils +void print_VkDebugUtilsMessengerCallbackDataFlagsEXT(const VkDebugUtilsMessengerCallbackDataFlagsEXT * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : \"%d\"%s\n", str, (int)(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_debug_utils +void print_VkDebugUtilsMessageTypeFlagsEXT(const VkDebugUtilsMessageTypeFlagsEXT * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : ", str); + const unsigned int max_bits = 64; + unsigned int _count = 0; + unsigned int checkBit = 1; + unsigned int n = *obj; + while (n) { + n &= (n-1); + _count++; + } + unsigned int b = *obj; + checkBit = 1; + vk_json_printf(_OUT, "\""); + if (*obj == 0) vk_json_printf(_OUT, "0"); + for (unsigned int i = 0, bitCount = 0; i < max_bits; i++, checkBit <<= 1) { + unsigned int res = b & checkBit; + if (res) { + bitCount++; + if (bitCount < _count) { + vk_json_printf(_OUT, "%s | ", VkDebugUtilsMessageTypeFlagBitsEXT_map(1<sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + /** Printing string inline. **/ + PRINT_SPACE + vk_json_printf(_OUT, "\"pLabelName\" : \"%s\",\n", (char*)obj->pLabelName); + + PRINT_SPACE + vk_json_printf(_OUT, "\"color\" :"); + if (obj->color) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (4); i++) { + char tmp[100]; + sprintf(tmp, "color_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (4); + print_float(&obj->color[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_debug_utils +void print_VkDebugUtilsObjectNameInfoEXT(const VkDebugUtilsObjectNameInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkObjectType(&obj->objectType, "objectType", 1); + + print_uint64_t(&obj->objectHandle, "objectHandle", 1); + + /** Printing string inline. **/ + PRINT_SPACE + vk_json_printf(_OUT, "\"pObjectName\" : \"%s\",\n", (char*)obj->pObjectName); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_debug_utils +void print_VkDebugUtilsMessengerCallbackDataEXT(const VkDebugUtilsMessengerCallbackDataEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDebugUtilsMessengerCallbackDataFlagsEXT(&obj->flags, "flags", 1); + + /** Printing string inline. **/ + PRINT_SPACE + vk_json_printf(_OUT, "\"pMessageIdName\" : \"%s\",\n", (char*)obj->pMessageIdName); + + print_int32_t(&obj->messageIdNumber, "messageIdNumber", 1); + + /** Printing string inline. **/ + PRINT_SPACE + vk_json_printf(_OUT, "\"pMessage\" : \"%s\",\n", (char*)obj->pMessage); + + print_uint32_t(&obj->queueLabelCount, "queueLabelCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pQueueLabels\" :"); + if (obj->pQueueLabels) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->queueLabelCount); i++) { + if (i+1 == *(&obj->queueLabelCount)) + print_VkDebugUtilsLabelEXT(&obj->pQueueLabels[i], "pQueueLabels", 0); + else + print_VkDebugUtilsLabelEXT(&obj->pQueueLabels[i], "pQueueLabels", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->cmdBufLabelCount, "cmdBufLabelCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pCmdBufLabels\" :"); + if (obj->pCmdBufLabels) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->cmdBufLabelCount); i++) { + if (i+1 == *(&obj->cmdBufLabelCount)) + print_VkDebugUtilsLabelEXT(&obj->pCmdBufLabels[i], "pCmdBufLabels", 0); + else + print_VkDebugUtilsLabelEXT(&obj->pCmdBufLabels[i], "pCmdBufLabels", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->objectCount, "objectCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pObjects\" :"); + if (obj->pObjects) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->objectCount); i++) { + if (i+1 == *(&obj->objectCount)) + print_VkDebugUtilsObjectNameInfoEXT(&obj->pObjects[i], "pObjects", 0); + else + print_VkDebugUtilsObjectNameInfoEXT(&obj->pObjects[i], "pObjects", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_debug_utils +void print_VkDebugUtilsMessengerCreateInfoEXT(const VkDebugUtilsMessengerCreateInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDebugUtilsMessengerCreateFlagsEXT(&obj->flags, "flags", 1); + + print_VkDebugUtilsMessageSeverityFlagsEXT(&obj->messageSeverity, "messageSeverity", 1); + + print_VkDebugUtilsMessageTypeFlagsEXT(&obj->messageType, "messageType", 1); + + /** Note: Ignoring function pointer (PFN_vkDebugUtilsMessengerCallbackEXT). **/ + + /** Note: Ignoring void* data. **/ + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_debug_utils +void print_VkDebugUtilsObjectTagInfoEXT(const VkDebugUtilsObjectTagInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkObjectType(&obj->objectType, "objectType", 1); + + print_uint64_t(&obj->objectHandle, "objectHandle", 1); + + print_uint64_t(&obj->tagName, "tagName", 1); + + print_size_t(&obj->tagSize, "tagSize", 1); + + /** Note: Ignoring void* data. **/ + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_sample_locations +void print_VkSampleLocationEXT(const VkSampleLocationEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_float(&obj->x, "x", 1); + + print_float(&obj->y, "y", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_sample_locations +void print_VkSampleLocationsInfoEXT(const VkSampleLocationsInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkSampleCountFlagBits(&obj->sampleLocationsPerPixel, "sampleLocationsPerPixel", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"sampleLocationGridSize\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->sampleLocationGridSize, "sampleLocationGridSize", 1); + } + + print_uint32_t(&obj->sampleLocationsCount, "sampleLocationsCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pSampleLocations\" :"); + if (obj->pSampleLocations) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->sampleLocationsCount); i++) { + if (i+1 == *(&obj->sampleLocationsCount)) + print_VkSampleLocationEXT(&obj->pSampleLocations[i], "pSampleLocations", 0); + else + print_VkSampleLocationEXT(&obj->pSampleLocations[i], "pSampleLocations", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_sample_locations +void print_VkAttachmentSampleLocationsEXT(const VkAttachmentSampleLocationsEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint32_t(&obj->attachmentIndex, "attachmentIndex", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"sampleLocationsInfo\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkSampleLocationsInfoEXT(&obj->sampleLocationsInfo, "sampleLocationsInfo", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_sample_locations +void print_VkSubpassSampleLocationsEXT(const VkSubpassSampleLocationsEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint32_t(&obj->subpassIndex, "subpassIndex", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"sampleLocationsInfo\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkSampleLocationsInfoEXT(&obj->sampleLocationsInfo, "sampleLocationsInfo", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_sample_locations +void print_VkRenderPassSampleLocationsBeginInfoEXT(const VkRenderPassSampleLocationsBeginInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->attachmentInitialSampleLocationsCount, "attachmentInitialSampleLocationsCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pAttachmentInitialSampleLocations\" :"); + if (obj->pAttachmentInitialSampleLocations) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->attachmentInitialSampleLocationsCount); i++) { + if (i+1 == *(&obj->attachmentInitialSampleLocationsCount)) + print_VkAttachmentSampleLocationsEXT(&obj->pAttachmentInitialSampleLocations[i], "pAttachmentInitialSampleLocations", 0); + else + print_VkAttachmentSampleLocationsEXT(&obj->pAttachmentInitialSampleLocations[i], "pAttachmentInitialSampleLocations", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->postSubpassSampleLocationsCount, "postSubpassSampleLocationsCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pPostSubpassSampleLocations\" :"); + if (obj->pPostSubpassSampleLocations) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->postSubpassSampleLocationsCount); i++) { + if (i+1 == *(&obj->postSubpassSampleLocationsCount)) + print_VkSubpassSampleLocationsEXT(&obj->pPostSubpassSampleLocations[i], "pPostSubpassSampleLocations", 0); + else + print_VkSubpassSampleLocationsEXT(&obj->pPostSubpassSampleLocations[i], "pPostSubpassSampleLocations", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_sample_locations +void print_VkPipelineSampleLocationsStateCreateInfoEXT(const VkPipelineSampleLocationsStateCreateInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->sampleLocationsEnable, "sampleLocationsEnable", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"sampleLocationsInfo\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkSampleLocationsInfoEXT(&obj->sampleLocationsInfo, "sampleLocationsInfo", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_sample_locations +void print_VkPhysicalDeviceSampleLocationsPropertiesEXT(const VkPhysicalDeviceSampleLocationsPropertiesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkSampleCountFlags(&obj->sampleLocationSampleCounts, "sampleLocationSampleCounts", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"maxSampleLocationGridSize\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->maxSampleLocationGridSize, "maxSampleLocationGridSize", 1); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"sampleLocationCoordinateRange\" :"); + if (obj->sampleLocationCoordinateRange) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (2); i++) { + char tmp[100]; + sprintf(tmp, "sampleLocationCoordinateRange_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (2); + print_float(&obj->sampleLocationCoordinateRange[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->sampleLocationSubPixelBits, "sampleLocationSubPixelBits", 1); + + print_VkBool32(&obj->variableSampleLocations, "variableSampleLocations", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_sample_locations +void print_VkMultisamplePropertiesEXT(const VkMultisamplePropertiesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"maxSampleLocationGridSize\" :"); + { + vk_json_printf(_OUT, "\n"); + print_VkExtent2D(&obj->maxSampleLocationGridSize, "maxSampleLocationGridSize", 0); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_blend_operation_advanced +static const char* VkBlendOverlapEXT_map(int o) { +switch (o) { + case 0: return "VK_BLEND_OVERLAP_UNCORRELATED_EXT"; + case 1: return "VK_BLEND_OVERLAP_DISJOINT_EXT"; + case 2: return "VK_BLEND_OVERLAP_CONJOINT_EXT"; + } + return NULL; +} +void print_VkBlendOverlapEXT(const VkBlendOverlapEXT* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkBlendOverlapEXT_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_blend_operation_advanced +void print_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->advancedBlendCoherentOperations, "advancedBlendCoherentOperations", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_blend_operation_advanced +void print_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->advancedBlendMaxColorAttachments, "advancedBlendMaxColorAttachments", 1); + + print_VkBool32(&obj->advancedBlendIndependentBlend, "advancedBlendIndependentBlend", 1); + + print_VkBool32(&obj->advancedBlendNonPremultipliedSrcColor, "advancedBlendNonPremultipliedSrcColor", 1); + + print_VkBool32(&obj->advancedBlendNonPremultipliedDstColor, "advancedBlendNonPremultipliedDstColor", 1); + + print_VkBool32(&obj->advancedBlendCorrelatedOverlap, "advancedBlendCorrelatedOverlap", 1); + + print_VkBool32(&obj->advancedBlendAllOperations, "advancedBlendAllOperations", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_blend_operation_advanced +void print_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const VkPipelineColorBlendAdvancedStateCreateInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->srcPremultiplied, "srcPremultiplied", 1); + + print_VkBool32(&obj->dstPremultiplied, "dstPremultiplied", 1); + + print_VkBlendOverlapEXT(&obj->blendOverlap, "blendOverlap", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +static const char* VkFormatFeatureFlagBits2KHR_map(int o) { +switch (o) { + case (1 << 0): return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR"; + case (1 << 1): return "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR"; + case (1 << 2): return "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR"; + case (1 << 3): return "VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR"; + case (1 << 4): return "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR"; + case (1 << 5): return "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR"; + case (1 << 6): return "VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR"; + case (1 << 7): return "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR"; + case (1 << 8): return "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR"; + case (1 << 9): return "VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR"; + case (1 << 10): return "VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR"; + case (1 << 11): return "VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR"; + case (1 << 12): return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR"; + case (1 << 13): return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT"; + case (1 << 14): return "VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR"; + case (1 << 15): return "VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR"; + case (1 << 16): return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR"; + case (1 << 17): return "VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR"; + case (1 << 18): return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR"; + case (1 << 19): return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR"; + case (1 << 20): return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR"; + case (1 << 21): return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR"; + case (1 << 22): return "VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR"; + case (1 << 23): return "VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR"; + case (1 << 31): return "VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR"; + case (1 << 32): return "VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR"; + case (1 << 33): return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR"; + case (1 << 25): return "VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR"; + case (1 << 26): return "VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR"; + case (1 << 29): return "VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR"; + case (1 << 24): return "VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT"; + case (1 << 30): return "VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; + case (1 << 27): return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR"; + case (1 << 28): return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR"; + } + return NULL; +} +void print_VkFormatFeatureFlagBits2KHR(const VkFormatFeatureFlagBits2KHR* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkFormatFeatureFlagBits2KHR_map(*obj), commaNeeded ? "," : ""); +} + +void print_VkFormatFeatureFlags2KHR(const VkFormatFeatureFlags2KHR * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : \"%d\"%s\n", str, (int)(*obj), commaNeeded ? "," : ""); +} + +#ifdef VK_EXT_image_drm_format_modifier +void print_VkDrmFormatModifierPropertiesEXT(const VkDrmFormatModifierPropertiesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint64_t(&obj->drmFormatModifier, "drmFormatModifier", 1); + + print_uint32_t(&obj->drmFormatModifierPlaneCount, "drmFormatModifierPlaneCount", 1); + + print_VkFormatFeatureFlags(&obj->drmFormatModifierTilingFeatures, "drmFormatModifierTilingFeatures", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_image_drm_format_modifier +void print_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->drmFormatModifierCount, "drmFormatModifierCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pDrmFormatModifierProperties\" :"); + if (obj->pDrmFormatModifierProperties) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->drmFormatModifierCount); i++) { + if (i+1 == *(&obj->drmFormatModifierCount)) + print_VkDrmFormatModifierPropertiesEXT(&obj->pDrmFormatModifierProperties[i], "pDrmFormatModifierProperties", 0); + else + print_VkDrmFormatModifierPropertiesEXT(&obj->pDrmFormatModifierProperties[i], "pDrmFormatModifierProperties", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_image_drm_format_modifier +void print_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint64_t(&obj->drmFormatModifier, "drmFormatModifier", 1); + + print_VkSharingMode(&obj->sharingMode, "sharingMode", 1); + + print_uint32_t(&obj->queueFamilyIndexCount, "queueFamilyIndexCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pQueueFamilyIndices\" :"); + if (obj->pQueueFamilyIndices) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->queueFamilyIndexCount); i++) { + char tmp[100]; + sprintf(tmp, "pQueueFamilyIndices_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->queueFamilyIndexCount); + print_uint32_t(&obj->pQueueFamilyIndices[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_image_drm_format_modifier +void print_VkImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->drmFormatModifierCount, "drmFormatModifierCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pDrmFormatModifiers\" :"); + if (obj->pDrmFormatModifiers) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->drmFormatModifierCount); i++) { + char tmp[100]; + sprintf(tmp, "pDrmFormatModifiers_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->drmFormatModifierCount); + print_uint64_t(&obj->pDrmFormatModifiers[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_image_drm_format_modifier +void print_VkImageDrmFormatModifierExplicitCreateInfoEXT(const VkImageDrmFormatModifierExplicitCreateInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint64_t(&obj->drmFormatModifier, "drmFormatModifier", 1); + + print_uint32_t(&obj->drmFormatModifierPlaneCount, "drmFormatModifierPlaneCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pPlaneLayouts\" :"); + if (obj->pPlaneLayouts) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->drmFormatModifierPlaneCount); i++) { + if (i+1 == *(&obj->drmFormatModifierPlaneCount)) + print_VkSubresourceLayout(&obj->pPlaneLayouts[i], "pPlaneLayouts", 0); + else + print_VkSubresourceLayout(&obj->pPlaneLayouts[i], "pPlaneLayouts", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_image_drm_format_modifier +void print_VkImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint64_t(&obj->drmFormatModifier, "drmFormatModifier", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_image_drm_format_modifier +void print_VkDrmFormatModifierProperties2EXT(const VkDrmFormatModifierProperties2EXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint64_t(&obj->drmFormatModifier, "drmFormatModifier", 1); + + print_uint32_t(&obj->drmFormatModifierPlaneCount, "drmFormatModifierPlaneCount", 1); + + print_VkFormatFeatureFlags2KHR(&obj->drmFormatModifierTilingFeatures, "drmFormatModifierTilingFeatures", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_image_drm_format_modifier +void print_VkDrmFormatModifierPropertiesList2EXT(const VkDrmFormatModifierPropertiesList2EXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->drmFormatModifierCount, "drmFormatModifierCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pDrmFormatModifierProperties\" :"); + if (obj->pDrmFormatModifierProperties) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->drmFormatModifierCount); i++) { + if (i+1 == *(&obj->drmFormatModifierCount)) + print_VkDrmFormatModifierProperties2EXT(&obj->pDrmFormatModifierProperties[i], "pDrmFormatModifierProperties", 0); + else + print_VkDrmFormatModifierProperties2EXT(&obj->pDrmFormatModifierProperties[i], "pDrmFormatModifierProperties", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_filter_cubic +void print_VkPhysicalDeviceImageViewImageFormatInfoEXT(const VkPhysicalDeviceImageViewImageFormatInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkImageViewType(&obj->imageViewType, "imageViewType", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_filter_cubic +void print_VkFilterCubicImageViewImageFormatPropertiesEXT(const VkFilterCubicImageViewImageFormatPropertiesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->filterCubic, "filterCubic", 1); + + print_VkBool32(&obj->filterCubicMinmax, "filterCubicMinmax", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_global_priority +static const char* VkQueueGlobalPriorityEXT_map(int o) { +switch (o) { + case 128: return "VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT"; + case 256: return "VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT"; + case 512: return "VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT"; + case 1024: return "VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT"; + } + return NULL; +} +void print_VkQueueGlobalPriorityEXT(const VkQueueGlobalPriorityEXT* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkQueueGlobalPriorityEXT_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_global_priority +void print_VkDeviceQueueGlobalPriorityCreateInfoEXT(const VkDeviceQueueGlobalPriorityCreateInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkQueueGlobalPriorityEXT(&obj->globalPriority, "globalPriority", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_external_memory_host +void print_VkImportMemoryHostPointerInfoEXT(const VkImportMemoryHostPointerInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkExternalMemoryHandleTypeFlagBits(&obj->handleType, "handleType", 1); + + /** Note: Ignoring void* data. **/ + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_external_memory_host +void print_VkMemoryHostPointerPropertiesEXT(const VkMemoryHostPointerPropertiesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->memoryTypeBits, "memoryTypeBits", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_external_memory_host +void print_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDeviceSize(&obj->minImportedHostPointerAlignment, "minImportedHostPointerAlignment", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_calibrated_timestamps +static const char* VkTimeDomainEXT_map(int o) { +switch (o) { + case 0: return "VK_TIME_DOMAIN_DEVICE_EXT"; + case 1: return "VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT"; + case 2: return "VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT"; + case 3: return "VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT"; + } + return NULL; +} +void print_VkTimeDomainEXT(const VkTimeDomainEXT* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkTimeDomainEXT_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_calibrated_timestamps +void print_VkCalibratedTimestampInfoEXT(const VkCalibratedTimestampInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkTimeDomainEXT(&obj->timeDomain, "timeDomain", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_vertex_attribute_divisor +void print_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->maxVertexAttribDivisor, "maxVertexAttribDivisor", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_vertex_attribute_divisor +void print_VkVertexInputBindingDivisorDescriptionEXT(const VkVertexInputBindingDivisorDescriptionEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_uint32_t(&obj->binding, "binding", 1); + + print_uint32_t(&obj->divisor, "divisor", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_vertex_attribute_divisor +void print_VkPipelineVertexInputDivisorStateCreateInfoEXT(const VkPipelineVertexInputDivisorStateCreateInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->vertexBindingDivisorCount, "vertexBindingDivisorCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pVertexBindingDivisors\" :"); + if (obj->pVertexBindingDivisors) { + vk_json_printf(_OUT, "\n"); + PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->vertexBindingDivisorCount); i++) { + if (i+1 == *(&obj->vertexBindingDivisorCount)) + print_VkVertexInputBindingDivisorDescriptionEXT(&obj->pVertexBindingDivisors[i], "pVertexBindingDivisors", 0); + else + print_VkVertexInputBindingDivisorDescriptionEXT(&obj->pVertexBindingDivisors[i], "pVertexBindingDivisors", 1); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } + else + { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_vertex_attribute_divisor +void print_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->vertexAttributeInstanceRateDivisor, "vertexAttributeInstanceRateDivisor", 1); + + print_VkBool32(&obj->vertexAttributeInstanceRateZeroDivisor, "vertexAttributeInstanceRateZeroDivisor", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_pci_bus_info +void print_VkPhysicalDevicePCIBusInfoPropertiesEXT(const VkPhysicalDevicePCIBusInfoPropertiesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->pciDomain, "pciDomain", 1); + + print_uint32_t(&obj->pciBus, "pciBus", 1); + + print_uint32_t(&obj->pciDevice, "pciDevice", 1); + + print_uint32_t(&obj->pciFunction, "pciFunction", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_subgroup_size_control +void print_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->subgroupSizeControl, "subgroupSizeControl", 1); + + print_VkBool32(&obj->computeFullSubgroups, "computeFullSubgroups", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_subgroup_size_control +void print_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->minSubgroupSize, "minSubgroupSize", 1); + + print_uint32_t(&obj->maxSubgroupSize, "maxSubgroupSize", 1); + + print_uint32_t(&obj->maxComputeWorkgroupSubgroups, "maxComputeWorkgroupSubgroups", 1); + + print_VkShaderStageFlags(&obj->requiredSubgroupSizeStages, "requiredSubgroupSizeStages", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_subgroup_size_control +void print_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->requiredSubgroupSize, "requiredSubgroupSize", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_shader_image_atomic_int64 +void print_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->shaderImageInt64Atomics, "shaderImageInt64Atomics", 1); + + print_VkBool32(&obj->sparseImageInt64Atomics, "sparseImageInt64Atomics", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_memory_budget +void print_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const VkPhysicalDeviceMemoryBudgetPropertiesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"heapBudget\" :"); + if (obj->heapBudget) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_MAX_MEMORY_HEAPS); i++) { + char tmp[100]; + sprintf(tmp, "heapBudget_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_MAX_MEMORY_HEAPS); + print_VkDeviceSize(&obj->heapBudget[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + PRINT_SPACE + vk_json_printf(_OUT, "\"heapUsage\" :"); + if (obj->heapUsage) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < (VK_MAX_MEMORY_HEAPS); i++) { + char tmp[100]; + sprintf(tmp, "heapUsage_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != (VK_MAX_MEMORY_HEAPS); + print_VkDeviceSize(&obj->heapUsage[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_validation_features +static const char* VkValidationFeatureEnableEXT_map(int o) { +switch (o) { + case 0: return "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT"; + case 1: return "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT"; + case 2: return "VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT"; + case 3: return "VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT"; + case 4: return "VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT"; + } + return NULL; +} +void print_VkValidationFeatureEnableEXT(const VkValidationFeatureEnableEXT* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkValidationFeatureEnableEXT_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_validation_features +static const char* VkValidationFeatureDisableEXT_map(int o) { +switch (o) { + case 0: return "VK_VALIDATION_FEATURE_DISABLE_ALL_EXT"; + case 1: return "VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT"; + case 2: return "VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT"; + case 3: return "VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT"; + case 4: return "VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT"; + case 5: return "VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT"; + case 6: return "VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT"; + case 7: return "VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT"; + } + return NULL; +} +void print_VkValidationFeatureDisableEXT(const VkValidationFeatureDisableEXT* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkValidationFeatureDisableEXT_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_validation_features +void print_VkValidationFeaturesEXT(const VkValidationFeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->enabledValidationFeatureCount, "enabledValidationFeatureCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pEnabledValidationFeatures\" :"); + if (obj->pEnabledValidationFeatures) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->enabledValidationFeatureCount); i++) { + char tmp[100]; + sprintf(tmp, "pEnabledValidationFeatures_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->enabledValidationFeatureCount); + print_VkValidationFeatureEnableEXT(&obj->pEnabledValidationFeatures[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "],\n"); + } else { + vk_json_printf(_OUT, " \"NULL\",\n"); + } + + print_uint32_t(&obj->disabledValidationFeatureCount, "disabledValidationFeatureCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pDisabledValidationFeatures\" :"); + if (obj->pDisabledValidationFeatures) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->disabledValidationFeatureCount); i++) { + char tmp[100]; + sprintf(tmp, "pDisabledValidationFeatures_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->disabledValidationFeatureCount); + print_VkValidationFeatureDisableEXT(&obj->pDisabledValidationFeatures[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_fragment_shader_interlock +void print_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->fragmentShaderSampleInterlock, "fragmentShaderSampleInterlock", 1); + + print_VkBool32(&obj->fragmentShaderPixelInterlock, "fragmentShaderPixelInterlock", 1); + + print_VkBool32(&obj->fragmentShaderShadingRateInterlock, "fragmentShaderShadingRateInterlock", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_ycbcr_image_arrays +void print_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->ycbcrImageArrays, "ycbcrImageArrays", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_headless_surface +void print_VkHeadlessSurfaceCreateFlagsEXT(const VkHeadlessSurfaceCreateFlagsEXT * obj, const char* str, int commaNeeded) { + PRINT_SPACE + vk_json_printf(_OUT, "\"%s\" : \"%d\"%s\n", str, (int)(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_headless_surface +void print_VkHeadlessSurfaceCreateInfoEXT(const VkHeadlessSurfaceCreateInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkHeadlessSurfaceCreateFlagsEXT(&obj->flags, "flags", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_line_rasterization +static const char* VkLineRasterizationModeEXT_map(int o) { +switch (o) { + case 0: return "VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT"; + case 1: return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT"; + case 2: return "VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT"; + case 3: return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT"; + } + return NULL; +} +void print_VkLineRasterizationModeEXT(const VkLineRasterizationModeEXT* obj, const char* str, int commaNeeded) { + PRINT_SPACE + if (strncmp(str, "", 255)) vk_json_printf(_OUT, "\"%s\" : ", str); + vk_json_printf(_OUT, "\"%s\"%s\n", VkLineRasterizationModeEXT_map(*obj), commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_line_rasterization +void print_VkPhysicalDeviceLineRasterizationFeaturesEXT(const VkPhysicalDeviceLineRasterizationFeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->rectangularLines, "rectangularLines", 1); + + print_VkBool32(&obj->bresenhamLines, "bresenhamLines", 1); + + print_VkBool32(&obj->smoothLines, "smoothLines", 1); + + print_VkBool32(&obj->stippledRectangularLines, "stippledRectangularLines", 1); + + print_VkBool32(&obj->stippledBresenhamLines, "stippledBresenhamLines", 1); + + print_VkBool32(&obj->stippledSmoothLines, "stippledSmoothLines", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_line_rasterization +void print_VkPhysicalDeviceLineRasterizationPropertiesEXT(const VkPhysicalDeviceLineRasterizationPropertiesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->lineSubPixelPrecisionBits, "lineSubPixelPrecisionBits", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_line_rasterization +void print_VkPipelineRasterizationLineStateCreateInfoEXT(const VkPipelineRasterizationLineStateCreateInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkLineRasterizationModeEXT(&obj->lineRasterizationMode, "lineRasterizationMode", 1); + + print_VkBool32(&obj->stippledLineEnable, "stippledLineEnable", 1); + + print_uint32_t(&obj->lineStippleFactor, "lineStippleFactor", 1); + + print_uint16_t(&obj->lineStipplePattern, "lineStipplePattern", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_shader_atomic_float +void print_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->shaderBufferFloat32Atomics, "shaderBufferFloat32Atomics", 1); + + print_VkBool32(&obj->shaderBufferFloat32AtomicAdd, "shaderBufferFloat32AtomicAdd", 1); + + print_VkBool32(&obj->shaderBufferFloat64Atomics, "shaderBufferFloat64Atomics", 1); + + print_VkBool32(&obj->shaderBufferFloat64AtomicAdd, "shaderBufferFloat64AtomicAdd", 1); + + print_VkBool32(&obj->shaderSharedFloat32Atomics, "shaderSharedFloat32Atomics", 1); + + print_VkBool32(&obj->shaderSharedFloat32AtomicAdd, "shaderSharedFloat32AtomicAdd", 1); + + print_VkBool32(&obj->shaderSharedFloat64Atomics, "shaderSharedFloat64Atomics", 1); + + print_VkBool32(&obj->shaderSharedFloat64AtomicAdd, "shaderSharedFloat64AtomicAdd", 1); + + print_VkBool32(&obj->shaderImageFloat32Atomics, "shaderImageFloat32Atomics", 1); + + print_VkBool32(&obj->shaderImageFloat32AtomicAdd, "shaderImageFloat32AtomicAdd", 1); + + print_VkBool32(&obj->sparseImageFloat32Atomics, "sparseImageFloat32Atomics", 1); + + print_VkBool32(&obj->sparseImageFloat32AtomicAdd, "sparseImageFloat32AtomicAdd", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_index_type_uint8 +void print_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->indexTypeUint8, "indexTypeUint8", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_extended_dynamic_state +void print_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->extendedDynamicState, "extendedDynamicState", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_shader_demote_to_helper_invocation +void print_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->shaderDemoteToHelperInvocation, "shaderDemoteToHelperInvocation", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_texel_buffer_alignment +void print_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->texelBufferAlignment, "texelBufferAlignment", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_texel_buffer_alignment +void print_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDeviceSize(&obj->storageTexelBufferOffsetAlignmentBytes, "storageTexelBufferOffsetAlignmentBytes", 1); + + print_VkBool32(&obj->storageTexelBufferOffsetSingleTexelAlignment, "storageTexelBufferOffsetSingleTexelAlignment", 1); + + print_VkDeviceSize(&obj->uniformTexelBufferOffsetAlignmentBytes, "uniformTexelBufferOffsetAlignmentBytes", 1); + + print_VkBool32(&obj->uniformTexelBufferOffsetSingleTexelAlignment, "uniformTexelBufferOffsetSingleTexelAlignment", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_robustness2 +void print_VkPhysicalDeviceRobustness2FeaturesEXT(const VkPhysicalDeviceRobustness2FeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->robustBufferAccess2, "robustBufferAccess2", 1); + + print_VkBool32(&obj->robustImageAccess2, "robustImageAccess2", 1); + + print_VkBool32(&obj->nullDescriptor, "nullDescriptor", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_robustness2 +void print_VkPhysicalDeviceRobustness2PropertiesEXT(const VkPhysicalDeviceRobustness2PropertiesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkDeviceSize(&obj->robustStorageBufferAccessSizeAlignment, "robustStorageBufferAccessSizeAlignment", 1); + + print_VkDeviceSize(&obj->robustUniformBufferAccessSizeAlignment, "robustUniformBufferAccessSizeAlignment", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_custom_border_color +void print_VkSamplerCustomBorderColorCreateInfoEXT(const VkSamplerCustomBorderColorCreateInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkClearColorValue(&obj->customBorderColor, "customBorderColor", 1); + + print_VkFormat(&obj->format, "format", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_custom_border_color +void print_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const VkPhysicalDeviceCustomBorderColorPropertiesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->maxCustomBorderColorSamplers, "maxCustomBorderColorSamplers", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_custom_border_color +void print_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const VkPhysicalDeviceCustomBorderColorFeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->customBorderColors, "customBorderColors", 1); + + print_VkBool32(&obj->customBorderColorWithoutFormat, "customBorderColorWithoutFormat", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_ycbcr_2plane_444_formats +void print_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->ycbcr2plane444Formats, "ycbcr2plane444Formats", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_image_robustness +void print_VkPhysicalDeviceImageRobustnessFeaturesEXT(const VkPhysicalDeviceImageRobustnessFeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->robustImageAccess, "robustImageAccess", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_4444_formats +void print_VkPhysicalDevice4444FormatsFeaturesEXT(const VkPhysicalDevice4444FormatsFeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->formatA4R4G4B4, "formatA4R4G4B4", 1); + + print_VkBool32(&obj->formatA4B4G4R4, "formatA4B4G4R4", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_vertex_input_dynamic_state +void print_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->vertexInputDynamicState, "vertexInputDynamicState", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_vertex_input_dynamic_state +void print_VkVertexInputBindingDescription2EXT(const VkVertexInputBindingDescription2EXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->binding, "binding", 1); + + print_uint32_t(&obj->stride, "stride", 1); + + print_VkVertexInputRate(&obj->inputRate, "inputRate", 1); + + print_uint32_t(&obj->divisor, "divisor", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_vertex_input_dynamic_state +void print_VkVertexInputAttributeDescription2EXT(const VkVertexInputAttributeDescription2EXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->location, "location", 1); + + print_uint32_t(&obj->binding, "binding", 1); + + print_VkFormat(&obj->format, "format", 1); + + print_uint32_t(&obj->offset, "offset", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_extended_dynamic_state2 +void print_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->extendedDynamicState2, "extendedDynamicState2", 1); + + print_VkBool32(&obj->extendedDynamicState2LogicOp, "extendedDynamicState2LogicOp", 1); + + print_VkBool32(&obj->extendedDynamicState2PatchControlPoints, "extendedDynamicState2PatchControlPoints", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_color_write_enable +void print_VkPhysicalDeviceColorWriteEnableFeaturesEXT(const VkPhysicalDeviceColorWriteEnableFeaturesEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_VkBool32(&obj->colorWriteEnable, "colorWriteEnable", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_color_write_enable +void print_VkPipelineColorWriteCreateInfoEXT(const VkPipelineColorWriteCreateInfoEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->attachmentCount, "attachmentCount", 1); + + PRINT_SPACE + vk_json_printf(_OUT, "\"pColorWriteEnables\" :"); + if (obj->pColorWriteEnables) { + vk_json_printf(_OUT, "\n"); PRINT_SPACE + vk_json_printf(_OUT, "[\n"); + for (unsigned int i = 0; i < *(&obj->attachmentCount); i++) { + char tmp[100]; + sprintf(tmp, "pColorWriteEnables_%u", i); + INDENT(4); + int isCommaNeeded = (i+1) != *(&obj->attachmentCount); + print_VkBool32(&obj->pColorWriteEnables[i], "", isCommaNeeded); + INDENT(-4); + } + PRINT_SPACE + vk_json_printf(_OUT, "]\n"); + } else { + vk_json_printf(_OUT, " \"NULL\"\n"); + } + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif +#ifdef VK_EXT_application_parameters +void print_VkApplicationParametersEXT(const VkApplicationParametersEXT * obj, const char* s, int commaNeeded) { + (void)s; + PRINT_SPACE + vk_json_printf(_OUT, "{\n"); + INDENT(4); + + print_VkStructureType(&obj->sType, "sType", 1); + + if (obj->pNext) { + dumpPNextChain(obj->pNext); + } else { + PRINT_SPACE + vk_json_printf(_OUT, "\"pNext\" : \"NULL\",\n"); + } + + print_uint32_t(&obj->vendorID, "vendorID", 1); + + print_uint32_t(&obj->deviceID, "deviceID", 1); + + print_uint32_t(&obj->key, "key", 1); + + print_uint64_t(&obj->value, "value", 0); + + INDENT(-4); + PRINT_SPACE + vk_json_printf(_OUT, "}%s\n", commaNeeded ? "," : ""); +} + +#endif diff --git a/json/vulkan_json_gen.h b/json/vulkan_json_gen.h new file mode 100644 index 0000000..255df19 --- /dev/null +++ b/json/vulkan_json_gen.h @@ -0,0 +1,975 @@ + +/* +** Copyright (c) 2020 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + + +/********************************************************************************************/ +/** This code is generated. To make changes, please modify the scripts or the relevant xml **/ +/********************************************************************************************/ + +#pragma once + +#include +#include + +const char* getJSONOutput(void); +void resetJSONOutput(void); + +/*************************************** Begin prototypes ***********************************/ +void print_VkSampleMask(const VkSampleMask* obj, const char* str, int commaNeeded); +void print_VkBool32(const VkBool32* obj, const char* str, int commaNeeded); +void print_VkFlags(const VkFlags* obj, const char* str, int commaNeeded); +#ifdef VK_KHR_synchronization2 +void print_VkFlags64(const VkFlags64* obj, const char* str, int commaNeeded); +#endif +void print_VkDeviceSize(const VkDeviceSize* obj, const char* str, int commaNeeded); +void print_VkDeviceAddress(const VkDeviceAddress* obj, const char* str, int commaNeeded); +void print_VkFramebufferCreateFlags(const VkFramebufferCreateFlags* obj, const char* str, int commaNeeded); +void print_VkQueryPoolCreateFlags(const VkQueryPoolCreateFlags* obj, const char* str, int commaNeeded); +void print_VkRenderPassCreateFlags(const VkRenderPassCreateFlags* obj, const char* str, int commaNeeded); +void print_VkSamplerCreateFlags(const VkSamplerCreateFlags* obj, const char* str, int commaNeeded); +void print_VkPipelineLayoutCreateFlags(const VkPipelineLayoutCreateFlags* obj, const char* str, int commaNeeded); +void print_VkPipelineCacheCreateFlags(const VkPipelineCacheCreateFlags* obj, const char* str, int commaNeeded); +void print_VkPipelineDepthStencilStateCreateFlags(const VkPipelineDepthStencilStateCreateFlags* obj, const char* str, int commaNeeded); +void print_VkPipelineDynamicStateCreateFlags(const VkPipelineDynamicStateCreateFlags* obj, const char* str, int commaNeeded); +void print_VkPipelineColorBlendStateCreateFlags(const VkPipelineColorBlendStateCreateFlags* obj, const char* str, int commaNeeded); +void print_VkPipelineMultisampleStateCreateFlags(const VkPipelineMultisampleStateCreateFlags* obj, const char* str, int commaNeeded); +void print_VkPipelineRasterizationStateCreateFlags(const VkPipelineRasterizationStateCreateFlags* obj, const char* str, int commaNeeded); +void print_VkPipelineViewportStateCreateFlags(const VkPipelineViewportStateCreateFlags* obj, const char* str, int commaNeeded); +void print_VkPipelineTessellationStateCreateFlags(const VkPipelineTessellationStateCreateFlags* obj, const char* str, int commaNeeded); +void print_VkPipelineInputAssemblyStateCreateFlags(const VkPipelineInputAssemblyStateCreateFlags* obj, const char* str, int commaNeeded); +void print_VkPipelineVertexInputStateCreateFlags(const VkPipelineVertexInputStateCreateFlags* obj, const char* str, int commaNeeded); +void print_VkPipelineShaderStageCreateFlags(const VkPipelineShaderStageCreateFlags* obj, const char* str, int commaNeeded); +void print_VkDescriptorSetLayoutCreateFlags(const VkDescriptorSetLayoutCreateFlags* obj, const char* str, int commaNeeded); +void print_VkBufferViewCreateFlags(const VkBufferViewCreateFlags* obj, const char* str, int commaNeeded); +void print_VkInstanceCreateFlags(const VkInstanceCreateFlags* obj, const char* str, int commaNeeded); +void print_VkDeviceCreateFlags(const VkDeviceCreateFlags* obj, const char* str, int commaNeeded); +void print_VkDeviceQueueCreateFlags(const VkDeviceQueueCreateFlags* obj, const char* str, int commaNeeded); +void print_VkQueueFlags(const VkQueueFlags* obj, const char* str, int commaNeeded); +void print_VkMemoryPropertyFlags(const VkMemoryPropertyFlags* obj, const char* str, int commaNeeded); +void print_VkMemoryHeapFlags(const VkMemoryHeapFlags* obj, const char* str, int commaNeeded); +void print_VkAccessFlags(const VkAccessFlags* obj, const char* str, int commaNeeded); +void print_VkBufferUsageFlags(const VkBufferUsageFlags* obj, const char* str, int commaNeeded); +void print_VkBufferCreateFlags(const VkBufferCreateFlags* obj, const char* str, int commaNeeded); +void print_VkShaderStageFlags(const VkShaderStageFlags* obj, const char* str, int commaNeeded); +void print_VkImageUsageFlags(const VkImageUsageFlags* obj, const char* str, int commaNeeded); +void print_VkImageCreateFlags(const VkImageCreateFlags* obj, const char* str, int commaNeeded); +void print_VkImageViewCreateFlags(const VkImageViewCreateFlags* obj, const char* str, int commaNeeded); +void print_VkPipelineCreateFlags(const VkPipelineCreateFlags* obj, const char* str, int commaNeeded); +void print_VkColorComponentFlags(const VkColorComponentFlags* obj, const char* str, int commaNeeded); +void print_VkFenceCreateFlags(const VkFenceCreateFlags* obj, const char* str, int commaNeeded); +void print_VkSemaphoreCreateFlags(const VkSemaphoreCreateFlags* obj, const char* str, int commaNeeded); +void print_VkFormatFeatureFlags(const VkFormatFeatureFlags* obj, const char* str, int commaNeeded); +void print_VkQueryControlFlags(const VkQueryControlFlags* obj, const char* str, int commaNeeded); +void print_VkQueryResultFlags(const VkQueryResultFlags* obj, const char* str, int commaNeeded); +void print_VkEventCreateFlags(const VkEventCreateFlags* obj, const char* str, int commaNeeded); +void print_VkCommandPoolCreateFlags(const VkCommandPoolCreateFlags* obj, const char* str, int commaNeeded); +void print_VkCommandPoolResetFlags(const VkCommandPoolResetFlags* obj, const char* str, int commaNeeded); +void print_VkCommandBufferResetFlags(const VkCommandBufferResetFlags* obj, const char* str, int commaNeeded); +void print_VkCommandBufferUsageFlags(const VkCommandBufferUsageFlags* obj, const char* str, int commaNeeded); +void print_VkQueryPipelineStatisticFlags(const VkQueryPipelineStatisticFlags* obj, const char* str, int commaNeeded); +void print_VkMemoryMapFlags(const VkMemoryMapFlags* obj, const char* str, int commaNeeded); +void print_VkImageAspectFlags(const VkImageAspectFlags* obj, const char* str, int commaNeeded); +void print_VkSubpassDescriptionFlags(const VkSubpassDescriptionFlags* obj, const char* str, int commaNeeded); +void print_VkPipelineStageFlags(const VkPipelineStageFlags* obj, const char* str, int commaNeeded); +void print_VkSampleCountFlags(const VkSampleCountFlags* obj, const char* str, int commaNeeded); +void print_VkAttachmentDescriptionFlags(const VkAttachmentDescriptionFlags* obj, const char* str, int commaNeeded); +void print_VkStencilFaceFlags(const VkStencilFaceFlags* obj, const char* str, int commaNeeded); +void print_VkCullModeFlags(const VkCullModeFlags* obj, const char* str, int commaNeeded); +void print_VkDescriptorPoolCreateFlags(const VkDescriptorPoolCreateFlags* obj, const char* str, int commaNeeded); +void print_VkDescriptorPoolResetFlags(const VkDescriptorPoolResetFlags* obj, const char* str, int commaNeeded); +void print_VkDependencyFlags(const VkDependencyFlags* obj, const char* str, int commaNeeded); +#ifdef VK_VERSION_1_1 +void print_VkSubgroupFeatureFlags(const VkSubgroupFeatureFlags* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_performance_query +void print_VkPerformanceCounterDescriptionFlagsKHR(const VkPerformanceCounterDescriptionFlagsKHR* obj, const char* str, int commaNeeded); +void print_VkAcquireProfilingLockFlagsKHR(const VkAcquireProfilingLockFlagsKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_2 +void print_VkSemaphoreWaitFlags(const VkSemaphoreWaitFlags* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_object_refresh +void print_VkRefreshObjectFlagsKHR(const VkRefreshObjectFlagsKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_synchronization2 +void print_VkAccessFlags2KHR(const VkAccessFlags2KHR* obj, const char* str, int commaNeeded); +void print_VkPipelineStageFlags2KHR(const VkPipelineStageFlags2KHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_surface +void print_VkCompositeAlphaFlagsKHR(const VkCompositeAlphaFlagsKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_display +void print_VkDisplayPlaneAlphaFlagsKHR(const VkDisplayPlaneAlphaFlagsKHR* obj, const char* str, int commaNeeded); +void print_VkSurfaceTransformFlagsKHR(const VkSurfaceTransformFlagsKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_swapchain +void print_VkSwapchainCreateFlagsKHR(const VkSwapchainCreateFlagsKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_display +void print_VkDisplayModeCreateFlagsKHR(const VkDisplayModeCreateFlagsKHR* obj, const char* str, int commaNeeded); +void print_VkDisplaySurfaceCreateFlagsKHR(const VkDisplaySurfaceCreateFlagsKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_headless_surface +void print_VkHeadlessSurfaceCreateFlagsEXT(const VkHeadlessSurfaceCreateFlagsEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_1 +void print_VkPeerMemoryFeatureFlags(const VkPeerMemoryFeatureFlags* obj, const char* str, int commaNeeded); +void print_VkMemoryAllocateFlags(const VkMemoryAllocateFlags* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_swapchain +void print_VkDeviceGroupPresentModeFlagsKHR(const VkDeviceGroupPresentModeFlagsKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_1 +void print_VkExternalMemoryHandleTypeFlags(const VkExternalMemoryHandleTypeFlags* obj, const char* str, int commaNeeded); +void print_VkExternalMemoryFeatureFlags(const VkExternalMemoryFeatureFlags* obj, const char* str, int commaNeeded); +void print_VkExternalSemaphoreHandleTypeFlags(const VkExternalSemaphoreHandleTypeFlags* obj, const char* str, int commaNeeded); +void print_VkExternalSemaphoreFeatureFlags(const VkExternalSemaphoreFeatureFlags* obj, const char* str, int commaNeeded); +void print_VkSemaphoreImportFlags(const VkSemaphoreImportFlags* obj, const char* str, int commaNeeded); +void print_VkExternalFenceHandleTypeFlags(const VkExternalFenceHandleTypeFlags* obj, const char* str, int commaNeeded); +void print_VkExternalFenceFeatureFlags(const VkExternalFenceFeatureFlags* obj, const char* str, int commaNeeded); +void print_VkFenceImportFlags(const VkFenceImportFlags* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_display_surface_counter +void print_VkSurfaceCounterFlagsEXT(const VkSurfaceCounterFlagsEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_discard_rectangles +void print_VkPipelineDiscardRectangleStateCreateFlagsEXT(const VkPipelineDiscardRectangleStateCreateFlagsEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_debug_utils +void print_VkDebugUtilsMessageSeverityFlagsEXT(const VkDebugUtilsMessageSeverityFlagsEXT* obj, const char* str, int commaNeeded); +void print_VkDebugUtilsMessageTypeFlagsEXT(const VkDebugUtilsMessageTypeFlagsEXT* obj, const char* str, int commaNeeded); +void print_VkDebugUtilsMessengerCreateFlagsEXT(const VkDebugUtilsMessengerCreateFlagsEXT* obj, const char* str, int commaNeeded); +void print_VkDebugUtilsMessengerCallbackDataFlagsEXT(const VkDebugUtilsMessengerCallbackDataFlagsEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_conservative_rasterization +void print_VkPipelineRasterizationConservativeStateCreateFlagsEXT(const VkPipelineRasterizationConservativeStateCreateFlagsEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_2 +void print_VkDescriptorBindingFlags(const VkDescriptorBindingFlags* obj, const char* str, int commaNeeded); +void print_VkResolveModeFlags(const VkResolveModeFlags* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_depth_clip_enable +void print_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(const VkPipelineRasterizationDepthClipStateCreateFlagsEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_synchronization2 +void print_VkSubmitFlagsKHR(const VkSubmitFlagsKHR* obj, const char* str, int commaNeeded); +#endif +void print_VkInstance(const VkInstance* obj, const char* str, int commaNeeded); +void print_VkPhysicalDevice(const VkPhysicalDevice* obj, const char* str, int commaNeeded); +void print_VkDevice(const VkDevice* obj, const char* str, int commaNeeded); +void print_VkQueue(const VkQueue* obj, const char* str, int commaNeeded); +void print_VkCommandBuffer(const VkCommandBuffer* obj, const char* str, int commaNeeded); +void print_VkDeviceMemory(const VkDeviceMemory* obj, const char* str, int commaNeeded); +void print_VkCommandPool(const VkCommandPool* obj, const char* str, int commaNeeded); +void print_VkBuffer(const VkBuffer* obj, const char* str, int commaNeeded); +void print_VkBufferView(const VkBufferView* obj, const char* str, int commaNeeded); +void print_VkImage(const VkImage* obj, const char* str, int commaNeeded); +void print_VkImageView(const VkImageView* obj, const char* str, int commaNeeded); +void print_VkShaderModule(const VkShaderModule* obj, const char* str, int commaNeeded); +void print_VkPipeline(const VkPipeline* obj, const char* str, int commaNeeded); +void print_VkPipelineLayout(const VkPipelineLayout* obj, const char* str, int commaNeeded); +void print_VkSampler(const VkSampler* obj, const char* str, int commaNeeded); +void print_VkDescriptorSet(const VkDescriptorSet* obj, const char* str, int commaNeeded); +void print_VkDescriptorSetLayout(const VkDescriptorSetLayout* obj, const char* str, int commaNeeded); +void print_VkDescriptorPool(const VkDescriptorPool* obj, const char* str, int commaNeeded); +void print_VkFence(const VkFence* obj, const char* str, int commaNeeded); +void print_VkSemaphore(const VkSemaphore* obj, const char* str, int commaNeeded); +void print_VkEvent(const VkEvent* obj, const char* str, int commaNeeded); +void print_VkQueryPool(const VkQueryPool* obj, const char* str, int commaNeeded); +void print_VkFramebuffer(const VkFramebuffer* obj, const char* str, int commaNeeded); +void print_VkRenderPass(const VkRenderPass* obj, const char* str, int commaNeeded); +void print_VkPipelineCache(const VkPipelineCache* obj, const char* str, int commaNeeded); +#ifdef VK_VERSION_1_1 +void print_VkSamplerYcbcrConversion(const VkSamplerYcbcrConversion* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_display +void print_VkDisplayKHR(const VkDisplayKHR* obj, const char* str, int commaNeeded); +void print_VkDisplayModeKHR(const VkDisplayModeKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_surface +void print_VkSurfaceKHR(const VkSurfaceKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_swapchain +void print_VkSwapchainKHR(const VkSwapchainKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_debug_utils +void print_VkDebugUtilsMessengerEXT(const VkDebugUtilsMessengerEXT* obj, const char* str, int commaNeeded); +#endif +void print_VkAttachmentLoadOp(const VkAttachmentLoadOp* obj, const char* str, int commaNeeded); +void print_VkAttachmentStoreOp(const VkAttachmentStoreOp* obj, const char* str, int commaNeeded); +void print_VkBlendFactor(const VkBlendFactor* obj, const char* str, int commaNeeded); +void print_VkBlendOp(const VkBlendOp* obj, const char* str, int commaNeeded); +void print_VkBorderColor(const VkBorderColor* obj, const char* str, int commaNeeded); +void print_VkFramebufferCreateFlagBits(const VkFramebufferCreateFlagBits* obj, const char* str, int commaNeeded); +void print_VkRenderPassCreateFlagBits(const VkRenderPassCreateFlagBits* obj, const char* str, int commaNeeded); +void print_VkSamplerCreateFlagBits(const VkSamplerCreateFlagBits* obj, const char* str, int commaNeeded); +void print_VkPipelineCacheHeaderVersion(const VkPipelineCacheHeaderVersion* obj, const char* str, int commaNeeded); +#ifdef VKSC_VERSION_1_0 +void print_VkPipelineCacheCreateFlagBits(const VkPipelineCacheCreateFlagBits* obj, const char* str, int commaNeeded); +#endif +void print_VkPipelineShaderStageCreateFlagBits(const VkPipelineShaderStageCreateFlagBits* obj, const char* str, int commaNeeded); +void print_VkDescriptorSetLayoutCreateFlagBits(const VkDescriptorSetLayoutCreateFlagBits* obj, const char* str, int commaNeeded); +#ifdef VK_VERSION_1_1 +void print_VkDeviceQueueCreateFlagBits(const VkDeviceQueueCreateFlagBits* obj, const char* str, int commaNeeded); +#endif +void print_VkBufferCreateFlagBits(const VkBufferCreateFlagBits* obj, const char* str, int commaNeeded); +void print_VkBufferUsageFlagBits(const VkBufferUsageFlagBits* obj, const char* str, int commaNeeded); +void print_VkColorComponentFlagBits(const VkColorComponentFlagBits* obj, const char* str, int commaNeeded); +void print_VkComponentSwizzle(const VkComponentSwizzle* obj, const char* str, int commaNeeded); +void print_VkCommandPoolCreateFlagBits(const VkCommandPoolCreateFlagBits* obj, const char* str, int commaNeeded); +void print_VkCommandPoolResetFlagBits(const VkCommandPoolResetFlagBits* obj, const char* str, int commaNeeded); +void print_VkCommandBufferResetFlagBits(const VkCommandBufferResetFlagBits* obj, const char* str, int commaNeeded); +void print_VkCommandBufferLevel(const VkCommandBufferLevel* obj, const char* str, int commaNeeded); +void print_VkCommandBufferUsageFlagBits(const VkCommandBufferUsageFlagBits* obj, const char* str, int commaNeeded); +void print_VkCompareOp(const VkCompareOp* obj, const char* str, int commaNeeded); +void print_VkCullModeFlagBits(const VkCullModeFlagBits* obj, const char* str, int commaNeeded); +void print_VkDescriptorType(const VkDescriptorType* obj, const char* str, int commaNeeded); +void print_VkDynamicState(const VkDynamicState* obj, const char* str, int commaNeeded); +void print_VkFenceCreateFlagBits(const VkFenceCreateFlagBits* obj, const char* str, int commaNeeded); +void print_VkPolygonMode(const VkPolygonMode* obj, const char* str, int commaNeeded); +void print_VkFormat(const VkFormat* obj, const char* str, int commaNeeded); +void print_VkFormatFeatureFlagBits(const VkFormatFeatureFlagBits* obj, const char* str, int commaNeeded); +void print_VkFrontFace(const VkFrontFace* obj, const char* str, int commaNeeded); +void print_VkImageAspectFlagBits(const VkImageAspectFlagBits* obj, const char* str, int commaNeeded); +void print_VkImageCreateFlagBits(const VkImageCreateFlagBits* obj, const char* str, int commaNeeded); +void print_VkImageLayout(const VkImageLayout* obj, const char* str, int commaNeeded); +void print_VkImageTiling(const VkImageTiling* obj, const char* str, int commaNeeded); +void print_VkImageType(const VkImageType* obj, const char* str, int commaNeeded); +void print_VkImageUsageFlagBits(const VkImageUsageFlagBits* obj, const char* str, int commaNeeded); +void print_VkImageViewCreateFlagBits(const VkImageViewCreateFlagBits* obj, const char* str, int commaNeeded); +void print_VkImageViewType(const VkImageViewType* obj, const char* str, int commaNeeded); +void print_VkSharingMode(const VkSharingMode* obj, const char* str, int commaNeeded); +void print_VkIndexType(const VkIndexType* obj, const char* str, int commaNeeded); +void print_VkLogicOp(const VkLogicOp* obj, const char* str, int commaNeeded); +void print_VkMemoryHeapFlagBits(const VkMemoryHeapFlagBits* obj, const char* str, int commaNeeded); +void print_VkAccessFlagBits(const VkAccessFlagBits* obj, const char* str, int commaNeeded); +void print_VkMemoryPropertyFlagBits(const VkMemoryPropertyFlagBits* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceType(const VkPhysicalDeviceType* obj, const char* str, int commaNeeded); +void print_VkPipelineBindPoint(const VkPipelineBindPoint* obj, const char* str, int commaNeeded); +void print_VkPipelineCreateFlagBits(const VkPipelineCreateFlagBits* obj, const char* str, int commaNeeded); +void print_VkPrimitiveTopology(const VkPrimitiveTopology* obj, const char* str, int commaNeeded); +void print_VkQueryControlFlagBits(const VkQueryControlFlagBits* obj, const char* str, int commaNeeded); +void print_VkQueryPipelineStatisticFlagBits(const VkQueryPipelineStatisticFlagBits* obj, const char* str, int commaNeeded); +void print_VkQueryResultFlagBits(const VkQueryResultFlagBits* obj, const char* str, int commaNeeded); +void print_VkQueryType(const VkQueryType* obj, const char* str, int commaNeeded); +void print_VkQueueFlagBits(const VkQueueFlagBits* obj, const char* str, int commaNeeded); +void print_VkSubpassContents(const VkSubpassContents* obj, const char* str, int commaNeeded); +void print_VkResult(const VkResult* obj, const char* str, int commaNeeded); +void print_VkShaderStageFlagBits(const VkShaderStageFlagBits* obj, const char* str, int commaNeeded); +void print_VkStencilFaceFlagBits(const VkStencilFaceFlagBits* obj, const char* str, int commaNeeded); +void print_VkStencilOp(const VkStencilOp* obj, const char* str, int commaNeeded); +void print_VkStructureType(const VkStructureType* obj, const char* str, int commaNeeded); +void print_VkSystemAllocationScope(const VkSystemAllocationScope* obj, const char* str, int commaNeeded); +void print_VkInternalAllocationType(const VkInternalAllocationType* obj, const char* str, int commaNeeded); +void print_VkSamplerAddressMode(const VkSamplerAddressMode* obj, const char* str, int commaNeeded); +void print_VkFilter(const VkFilter* obj, const char* str, int commaNeeded); +void print_VkSamplerMipmapMode(const VkSamplerMipmapMode* obj, const char* str, int commaNeeded); +void print_VkVertexInputRate(const VkVertexInputRate* obj, const char* str, int commaNeeded); +void print_VkPipelineStageFlagBits(const VkPipelineStageFlagBits* obj, const char* str, int commaNeeded); +void print_VkSampleCountFlagBits(const VkSampleCountFlagBits* obj, const char* str, int commaNeeded); +void print_VkAttachmentDescriptionFlagBits(const VkAttachmentDescriptionFlagBits* obj, const char* str, int commaNeeded); +void print_VkDescriptorPoolCreateFlagBits(const VkDescriptorPoolCreateFlagBits* obj, const char* str, int commaNeeded); +void print_VkDependencyFlagBits(const VkDependencyFlagBits* obj, const char* str, int commaNeeded); +void print_VkObjectType(const VkObjectType* obj, const char* str, int commaNeeded); +void print_VkEventCreateFlagBits(const VkEventCreateFlagBits* obj, const char* str, int commaNeeded); +#ifdef VK_EXT_discard_rectangles +void print_VkDiscardRectangleModeEXT(const VkDiscardRectangleModeEXT* obj, const char* str, int commaNeeded); +#endif +void print_VkSubpassDescriptionFlagBits(const VkSubpassDescriptionFlagBits* obj, const char* str, int commaNeeded); +#ifdef VK_VERSION_1_1 +void print_VkPointClippingBehavior(const VkPointClippingBehavior* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_global_priority +void print_VkQueueGlobalPriorityEXT(const VkQueueGlobalPriorityEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_calibrated_timestamps +void print_VkTimeDomainEXT(const VkTimeDomainEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_conservative_rasterization +void print_VkConservativeRasterizationModeEXT(const VkConservativeRasterizationModeEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_2 +void print_VkResolveModeFlagBits(const VkResolveModeFlagBits* obj, const char* str, int commaNeeded); +void print_VkDescriptorBindingFlagBits(const VkDescriptorBindingFlagBits* obj, const char* str, int commaNeeded); +void print_VkSemaphoreType(const VkSemaphoreType* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_performance_query +void print_VkPerformanceCounterScopeKHR(const VkPerformanceCounterScopeKHR* obj, const char* str, int commaNeeded); +void print_VkPerformanceCounterUnitKHR(const VkPerformanceCounterUnitKHR* obj, const char* str, int commaNeeded); +void print_VkPerformanceCounterStorageKHR(const VkPerformanceCounterStorageKHR* obj, const char* str, int commaNeeded); +void print_VkPerformanceCounterDescriptionFlagBitsKHR(const VkPerformanceCounterDescriptionFlagBitsKHR* obj, const char* str, int commaNeeded); +void print_VkAcquireProfilingLockFlagBitsKHR(const VkAcquireProfilingLockFlagBitsKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_2 +void print_VkSemaphoreWaitFlagBits(const VkSemaphoreWaitFlagBits* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_line_rasterization +void print_VkLineRasterizationModeEXT(const VkLineRasterizationModeEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_object_refresh +void print_VkRefreshObjectFlagBitsKHR(const VkRefreshObjectFlagBitsKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VKSC_VERSION_1_0 +void print_VkFaultLevel(const VkFaultLevel* obj, const char* str, int commaNeeded); +void print_VkFaultType(const VkFaultType* obj, const char* str, int commaNeeded); +void print_VkFaultQueryBehavior(const VkFaultQueryBehavior* obj, const char* str, int commaNeeded); +void print_VkPipelineMatchControl(const VkPipelineMatchControl* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_synchronization2 +void print_VkAccessFlagBits2KHR(const VkAccessFlagBits2KHR* obj, const char* str, int commaNeeded); +void print_VkPipelineStageFlagBits2KHR(const VkPipelineStageFlagBits2KHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VKSC_VERSION_1_0 +void print_VkPipelineCacheValidationVersion(const VkPipelineCacheValidationVersion* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_surface +void print_VkColorSpaceKHR(const VkColorSpaceKHR* obj, const char* str, int commaNeeded); +void print_VkCompositeAlphaFlagBitsKHR(const VkCompositeAlphaFlagBitsKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_display +void print_VkDisplayPlaneAlphaFlagBitsKHR(const VkDisplayPlaneAlphaFlagBitsKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_surface +void print_VkPresentModeKHR(const VkPresentModeKHR* obj, const char* str, int commaNeeded); +void print_VkSurfaceTransformFlagBitsKHR(const VkSurfaceTransformFlagBitsKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_validation_features +void print_VkValidationFeatureEnableEXT(const VkValidationFeatureEnableEXT* obj, const char* str, int commaNeeded); +void print_VkValidationFeatureDisableEXT(const VkValidationFeatureDisableEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_1 +void print_VkExternalMemoryHandleTypeFlagBits(const VkExternalMemoryHandleTypeFlagBits* obj, const char* str, int commaNeeded); +void print_VkExternalMemoryFeatureFlagBits(const VkExternalMemoryFeatureFlagBits* obj, const char* str, int commaNeeded); +void print_VkExternalSemaphoreHandleTypeFlagBits(const VkExternalSemaphoreHandleTypeFlagBits* obj, const char* str, int commaNeeded); +void print_VkExternalSemaphoreFeatureFlagBits(const VkExternalSemaphoreFeatureFlagBits* obj, const char* str, int commaNeeded); +void print_VkSemaphoreImportFlagBits(const VkSemaphoreImportFlagBits* obj, const char* str, int commaNeeded); +void print_VkExternalFenceHandleTypeFlagBits(const VkExternalFenceHandleTypeFlagBits* obj, const char* str, int commaNeeded); +void print_VkExternalFenceFeatureFlagBits(const VkExternalFenceFeatureFlagBits* obj, const char* str, int commaNeeded); +void print_VkFenceImportFlagBits(const VkFenceImportFlagBits* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_display_surface_counter +void print_VkSurfaceCounterFlagBitsEXT(const VkSurfaceCounterFlagBitsEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_display_control +void print_VkDisplayPowerStateEXT(const VkDisplayPowerStateEXT* obj, const char* str, int commaNeeded); +void print_VkDeviceEventTypeEXT(const VkDeviceEventTypeEXT* obj, const char* str, int commaNeeded); +void print_VkDisplayEventTypeEXT(const VkDisplayEventTypeEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_1 +void print_VkPeerMemoryFeatureFlagBits(const VkPeerMemoryFeatureFlagBits* obj, const char* str, int commaNeeded); +void print_VkMemoryAllocateFlagBits(const VkMemoryAllocateFlagBits* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_swapchain +void print_VkDeviceGroupPresentModeFlagBitsKHR(const VkDeviceGroupPresentModeFlagBitsKHR* obj, const char* str, int commaNeeded); +void print_VkSwapchainCreateFlagBitsKHR(const VkSwapchainCreateFlagBitsKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_1 +void print_VkSubgroupFeatureFlagBits(const VkSubgroupFeatureFlagBits* obj, const char* str, int commaNeeded); +void print_VkTessellationDomainOrigin(const VkTessellationDomainOrigin* obj, const char* str, int commaNeeded); +void print_VkSamplerYcbcrModelConversion(const VkSamplerYcbcrModelConversion* obj, const char* str, int commaNeeded); +void print_VkSamplerYcbcrRange(const VkSamplerYcbcrRange* obj, const char* str, int commaNeeded); +void print_VkChromaLocation(const VkChromaLocation* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_2 +void print_VkSamplerReductionMode(const VkSamplerReductionMode* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_blend_operation_advanced +void print_VkBlendOverlapEXT(const VkBlendOverlapEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_debug_utils +void print_VkDebugUtilsMessageSeverityFlagBitsEXT(const VkDebugUtilsMessageSeverityFlagBitsEXT* obj, const char* str, int commaNeeded); +void print_VkDebugUtilsMessageTypeFlagBitsEXT(const VkDebugUtilsMessageTypeFlagBitsEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_2 +void print_VkShaderFloatControlsIndependence(const VkShaderFloatControlsIndependence* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_fragment_shading_rate +void print_VkFragmentShadingRateCombinerOpKHR(const VkFragmentShadingRateCombinerOpKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_synchronization2 +void print_VkSubmitFlagBitsKHR(const VkSubmitFlagBitsKHR* obj, const char* str, int commaNeeded); +#endif +void print_VkVendorId(const VkVendorId* obj, const char* str, int commaNeeded); +#ifdef VK_VERSION_1_2 +void print_VkDriverId(const VkDriverId* obj, const char* str, int commaNeeded); +#endif +void print_VkBaseOutStructure(const VkBaseOutStructure* obj, const char* str, int commaNeeded); +void print_VkBaseInStructure(const VkBaseInStructure* obj, const char* str, int commaNeeded); +void print_VkOffset2D(const VkOffset2D* obj, const char* str, int commaNeeded); +void print_VkOffset3D(const VkOffset3D* obj, const char* str, int commaNeeded); +void print_VkExtent2D(const VkExtent2D* obj, const char* str, int commaNeeded); +void print_VkExtent3D(const VkExtent3D* obj, const char* str, int commaNeeded); +void print_VkViewport(const VkViewport* obj, const char* str, int commaNeeded); +void print_VkRect2D(const VkRect2D* obj, const char* str, int commaNeeded); +void print_VkClearRect(const VkClearRect* obj, const char* str, int commaNeeded); +void print_VkComponentMapping(const VkComponentMapping* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceProperties(const VkPhysicalDeviceProperties* obj, const char* str, int commaNeeded); +void print_VkExtensionProperties(const VkExtensionProperties* obj, const char* str, int commaNeeded); +void print_VkLayerProperties(const VkLayerProperties* obj, const char* str, int commaNeeded); +void print_VkApplicationInfo(const VkApplicationInfo* obj, const char* str, int commaNeeded); +void print_VkAllocationCallbacks(const VkAllocationCallbacks* obj, const char* str, int commaNeeded); +void print_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo* obj, const char* str, int commaNeeded); +void print_VkDeviceCreateInfo(const VkDeviceCreateInfo* obj, const char* str, int commaNeeded); +void print_VkInstanceCreateInfo(const VkInstanceCreateInfo* obj, const char* str, int commaNeeded); +void print_VkQueueFamilyProperties(const VkQueueFamilyProperties* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceMemoryProperties(const VkPhysicalDeviceMemoryProperties* obj, const char* str, int commaNeeded); +void print_VkMemoryAllocateInfo(const VkMemoryAllocateInfo* obj, const char* str, int commaNeeded); +void print_VkMemoryRequirements(const VkMemoryRequirements* obj, const char* str, int commaNeeded); +void print_VkMemoryType(const VkMemoryType* obj, const char* str, int commaNeeded); +void print_VkMemoryHeap(const VkMemoryHeap* obj, const char* str, int commaNeeded); +void print_VkMappedMemoryRange(const VkMappedMemoryRange* obj, const char* str, int commaNeeded); +void print_VkFormatProperties(const VkFormatProperties* obj, const char* str, int commaNeeded); +void print_VkImageFormatProperties(const VkImageFormatProperties* obj, const char* str, int commaNeeded); +void print_VkDescriptorBufferInfo(const VkDescriptorBufferInfo* obj, const char* str, int commaNeeded); +void print_VkDescriptorImageInfo(const VkDescriptorImageInfo* obj, const char* str, int commaNeeded); +void print_VkWriteDescriptorSet(const VkWriteDescriptorSet* obj, const char* str, int commaNeeded); +void print_VkCopyDescriptorSet(const VkCopyDescriptorSet* obj, const char* str, int commaNeeded); +void print_VkBufferCreateInfo(const VkBufferCreateInfo* obj, const char* str, int commaNeeded); +void print_VkBufferViewCreateInfo(const VkBufferViewCreateInfo* obj, const char* str, int commaNeeded); +void print_VkImageSubresource(const VkImageSubresource* obj, const char* str, int commaNeeded); +void print_VkImageSubresourceLayers(const VkImageSubresourceLayers* obj, const char* str, int commaNeeded); +void print_VkImageSubresourceRange(const VkImageSubresourceRange* obj, const char* str, int commaNeeded); +void print_VkMemoryBarrier(const VkMemoryBarrier* obj, const char* str, int commaNeeded); +void print_VkBufferMemoryBarrier(const VkBufferMemoryBarrier* obj, const char* str, int commaNeeded); +void print_VkImageMemoryBarrier(const VkImageMemoryBarrier* obj, const char* str, int commaNeeded); +void print_VkImageCreateInfo(const VkImageCreateInfo* obj, const char* str, int commaNeeded); +void print_VkSubresourceLayout(const VkSubresourceLayout* obj, const char* str, int commaNeeded); +void print_VkImageViewCreateInfo(const VkImageViewCreateInfo* obj, const char* str, int commaNeeded); +void print_VkBufferCopy(const VkBufferCopy* obj, const char* str, int commaNeeded); +void print_VkImageCopy(const VkImageCopy* obj, const char* str, int commaNeeded); +void print_VkImageBlit(const VkImageBlit* obj, const char* str, int commaNeeded); +void print_VkBufferImageCopy(const VkBufferImageCopy* obj, const char* str, int commaNeeded); +void print_VkImageResolve(const VkImageResolve* obj, const char* str, int commaNeeded); +void print_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding* obj, const char* str, int commaNeeded); +void print_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo* obj, const char* str, int commaNeeded); +void print_VkDescriptorPoolSize(const VkDescriptorPoolSize* obj, const char* str, int commaNeeded); +void print_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo* obj, const char* str, int commaNeeded); +void print_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo* obj, const char* str, int commaNeeded); +void print_VkSpecializationMapEntry(const VkSpecializationMapEntry* obj, const char* str, int commaNeeded); +void print_VkSpecializationInfo(const VkSpecializationInfo* obj, const char* str, int commaNeeded); +void print_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo* obj, const char* str, int commaNeeded); +void print_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo* obj, const char* str, int commaNeeded); +void print_VkVertexInputBindingDescription(const VkVertexInputBindingDescription* obj, const char* str, int commaNeeded); +void print_VkVertexInputAttributeDescription(const VkVertexInputAttributeDescription* obj, const char* str, int commaNeeded); +void print_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo* obj, const char* str, int commaNeeded); +void print_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo* obj, const char* str, int commaNeeded); +void print_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo* obj, const char* str, int commaNeeded); +void print_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo* obj, const char* str, int commaNeeded); +void print_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo* obj, const char* str, int commaNeeded); +void print_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo* obj, const char* str, int commaNeeded); +void print_VkPipelineColorBlendAttachmentState(const VkPipelineColorBlendAttachmentState* obj, const char* str, int commaNeeded); +void print_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo* obj, const char* str, int commaNeeded); +void print_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo* obj, const char* str, int commaNeeded); +void print_VkStencilOpState(const VkStencilOpState* obj, const char* str, int commaNeeded); +void print_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo* obj, const char* str, int commaNeeded); +void print_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo* obj, const char* str, int commaNeeded); +void print_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo* obj, const char* str, int commaNeeded); +void print_VkPipelineCacheHeaderVersionOne(const VkPipelineCacheHeaderVersionOne* obj, const char* str, int commaNeeded); +#ifdef VKSC_VERSION_1_0 +void print_VkPipelineCacheStageValidationIndexEntry(const VkPipelineCacheStageValidationIndexEntry* obj, const char* str, int commaNeeded); +void print_VkPipelineCacheSafetyCriticalIndexEntry(const VkPipelineCacheSafetyCriticalIndexEntry* obj, const char* str, int commaNeeded); +void print_VkPipelineCacheHeaderVersionSafetyCriticalOne(const VkPipelineCacheHeaderVersionSafetyCriticalOne* obj, const char* str, int commaNeeded); +#endif +void print_VkPushConstantRange(const VkPushConstantRange* obj, const char* str, int commaNeeded); +void print_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo* obj, const char* str, int commaNeeded); +void print_VkSamplerCreateInfo(const VkSamplerCreateInfo* obj, const char* str, int commaNeeded); +void print_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo* obj, const char* str, int commaNeeded); +void print_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo* obj, const char* str, int commaNeeded); +void print_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo* obj, const char* str, int commaNeeded); +void print_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo* obj, const char* str, int commaNeeded); +void print_VkRenderPassBeginInfo(const VkRenderPassBeginInfo* obj, const char* str, int commaNeeded); +void print_VkClearDepthStencilValue(const VkClearDepthStencilValue* obj, const char* str, int commaNeeded); +void print_VkClearAttachment(const VkClearAttachment* obj, const char* str, int commaNeeded); +void print_VkAttachmentDescription(const VkAttachmentDescription* obj, const char* str, int commaNeeded); +void print_VkAttachmentReference(const VkAttachmentReference* obj, const char* str, int commaNeeded); +void print_VkSubpassDescription(const VkSubpassDescription* obj, const char* str, int commaNeeded); +void print_VkSubpassDependency(const VkSubpassDependency* obj, const char* str, int commaNeeded); +void print_VkRenderPassCreateInfo(const VkRenderPassCreateInfo* obj, const char* str, int commaNeeded); +void print_VkEventCreateInfo(const VkEventCreateInfo* obj, const char* str, int commaNeeded); +void print_VkFenceCreateInfo(const VkFenceCreateInfo* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceFeatures(const VkPhysicalDeviceFeatures* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceSparseProperties(const VkPhysicalDeviceSparseProperties* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceLimits(const VkPhysicalDeviceLimits* obj, const char* str, int commaNeeded); +void print_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo* obj, const char* str, int commaNeeded); +void print_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo* obj, const char* str, int commaNeeded); +void print_VkFramebufferCreateInfo(const VkFramebufferCreateInfo* obj, const char* str, int commaNeeded); +void print_VkDrawIndirectCommand(const VkDrawIndirectCommand* obj, const char* str, int commaNeeded); +void print_VkDrawIndexedIndirectCommand(const VkDrawIndexedIndirectCommand* obj, const char* str, int commaNeeded); +void print_VkDispatchIndirectCommand(const VkDispatchIndirectCommand* obj, const char* str, int commaNeeded); +void print_VkSubmitInfo(const VkSubmitInfo* obj, const char* str, int commaNeeded); +#ifdef VK_KHR_display +void print_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR* obj, const char* str, int commaNeeded); +void print_VkDisplayPlanePropertiesKHR(const VkDisplayPlanePropertiesKHR* obj, const char* str, int commaNeeded); +void print_VkDisplayModeParametersKHR(const VkDisplayModeParametersKHR* obj, const char* str, int commaNeeded); +void print_VkDisplayModePropertiesKHR(const VkDisplayModePropertiesKHR* obj, const char* str, int commaNeeded); +void print_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR* obj, const char* str, int commaNeeded); +void print_VkDisplayPlaneCapabilitiesKHR(const VkDisplayPlaneCapabilitiesKHR* obj, const char* str, int commaNeeded); +void print_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_display_swapchain +void print_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_surface +void print_VkSurfaceCapabilitiesKHR(const VkSurfaceCapabilitiesKHR* obj, const char* str, int commaNeeded); +void print_VkSurfaceFormatKHR(const VkSurfaceFormatKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_swapchain +void print_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR* obj, const char* str, int commaNeeded); +void print_VkPresentInfoKHR(const VkPresentInfoKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_validation_features +void print_VkValidationFeaturesEXT(const VkValidationFeaturesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_application_parameters +void print_VkApplicationParametersEXT(const VkApplicationParametersEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2* obj, const char* str, int commaNeeded); +void print_VkFormatProperties2(const VkFormatProperties2* obj, const char* str, int commaNeeded); +void print_VkImageFormatProperties2(const VkImageFormatProperties2* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2* obj, const char* str, int commaNeeded); +void print_VkQueueFamilyProperties2(const VkQueueFamilyProperties2* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_2 +void print_VkConformanceVersion(const VkConformanceVersion* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_incremental_present +void print_VkPresentRegionsKHR(const VkPresentRegionsKHR* obj, const char* str, int commaNeeded); +void print_VkPresentRegionKHR(const VkPresentRegionKHR* obj, const char* str, int commaNeeded); +void print_VkRectLayerKHR(const VkRectLayerKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceVariablePointerFeatures(const VkPhysicalDeviceVariablePointerFeatures* obj, const char* str, int commaNeeded); +void print_VkExternalMemoryProperties(const VkExternalMemoryProperties* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo* obj, const char* str, int commaNeeded); +void print_VkExternalImageFormatProperties(const VkExternalImageFormatProperties* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo* obj, const char* str, int commaNeeded); +void print_VkExternalBufferProperties(const VkExternalBufferProperties* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties* obj, const char* str, int commaNeeded); +void print_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo* obj, const char* str, int commaNeeded); +void print_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo* obj, const char* str, int commaNeeded); +void print_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_external_memory_fd +void print_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR* obj, const char* str, int commaNeeded); +void print_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR* obj, const char* str, int commaNeeded); +void print_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo* obj, const char* str, int commaNeeded); +void print_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties* obj, const char* str, int commaNeeded); +void print_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_external_semaphore_fd +void print_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR* obj, const char* str, int commaNeeded); +void print_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo* obj, const char* str, int commaNeeded); +void print_VkExternalFenceProperties(const VkExternalFenceProperties* obj, const char* str, int commaNeeded); +void print_VkExportFenceCreateInfo(const VkExportFenceCreateInfo* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_external_fence_fd +void print_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR* obj, const char* str, int commaNeeded); +void print_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties* obj, const char* str, int commaNeeded); +void print_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_display_surface_counter +void print_VkSurfaceCapabilities2EXT(const VkSurfaceCapabilities2EXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_display_control +void print_VkDisplayPowerInfoEXT(const VkDisplayPowerInfoEXT* obj, const char* str, int commaNeeded); +void print_VkDeviceEventInfoEXT(const VkDeviceEventInfoEXT* obj, const char* str, int commaNeeded); +void print_VkDisplayEventInfoEXT(const VkDisplayEventInfoEXT* obj, const char* str, int commaNeeded); +void print_VkSwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties* obj, const char* str, int commaNeeded); +void print_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo* obj, const char* str, int commaNeeded); +void print_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo* obj, const char* str, int commaNeeded); +void print_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo* obj, const char* str, int commaNeeded); +void print_VkBindImageMemoryInfo(const VkBindImageMemoryInfo* obj, const char* str, int commaNeeded); +void print_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo* obj, const char* str, int commaNeeded); +void print_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo* obj, const char* str, int commaNeeded); +void print_VkDeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo* obj, const char* str, int commaNeeded); +void print_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_swapchain +void print_VkDeviceGroupPresentCapabilitiesKHR(const VkDeviceGroupPresentCapabilitiesKHR* obj, const char* str, int commaNeeded); +void print_VkImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR* obj, const char* str, int commaNeeded); +void print_VkBindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR* obj, const char* str, int commaNeeded); +void print_VkAcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR* obj, const char* str, int commaNeeded); +void print_VkDeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_1 +void print_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_swapchain +void print_VkDeviceGroupSwapchainCreateInfoKHR(const VkDeviceGroupSwapchainCreateInfoKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_hdr_metadata +void print_VkXYColorEXT(const VkXYColorEXT* obj, const char* str, int commaNeeded); +void print_VkHdrMetadataEXT(const VkHdrMetadataEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_discard_rectangles +void print_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* obj, const char* str, int commaNeeded); +void print_VkPipelineDiscardRectangleStateCreateInfoEXT(const VkPipelineDiscardRectangleStateCreateInfoEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_1 +void print_VkInputAttachmentAspectReference(const VkInputAttachmentAspectReference* obj, const char* str, int commaNeeded); +void print_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_get_surface_capabilities2 +void print_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR* obj, const char* str, int commaNeeded); +void print_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR* obj, const char* str, int commaNeeded); +void print_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_get_display_properties2 +void print_VkDisplayProperties2KHR(const VkDisplayProperties2KHR* obj, const char* str, int commaNeeded); +void print_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR* obj, const char* str, int commaNeeded); +void print_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR* obj, const char* str, int commaNeeded); +void print_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR* obj, const char* str, int commaNeeded); +void print_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_shared_presentable_image +void print_VkSharedPresentSurfaceCapabilitiesKHR(const VkSharedPresentSurfaceCapabilitiesKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_1 +void print_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2* obj, const char* str, int commaNeeded); +void print_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2* obj, const char* str, int commaNeeded); +void print_VkMemoryRequirements2(const VkMemoryRequirements2* obj, const char* str, int commaNeeded); +void print_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties* obj, const char* str, int commaNeeded); +void print_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements* obj, const char* str, int commaNeeded); +void print_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo* obj, const char* str, int commaNeeded); +void print_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo* obj, const char* str, int commaNeeded); +void print_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo* obj, const char* str, int commaNeeded); +void print_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo* obj, const char* str, int commaNeeded); +void print_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo* obj, const char* str, int commaNeeded); +void print_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo* obj, const char* str, int commaNeeded); +void print_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures* obj, const char* str, int commaNeeded); +void print_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties* obj, const char* str, int commaNeeded); +void print_VkProtectedSubmitInfo(const VkProtectedSubmitInfo* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties* obj, const char* str, int commaNeeded); +void print_VkDeviceQueueInfo2(const VkDeviceQueueInfo2* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_sample_locations +void print_VkSampleLocationEXT(const VkSampleLocationEXT* obj, const char* str, int commaNeeded); +void print_VkSampleLocationsInfoEXT(const VkSampleLocationsInfoEXT* obj, const char* str, int commaNeeded); +void print_VkAttachmentSampleLocationsEXT(const VkAttachmentSampleLocationsEXT* obj, const char* str, int commaNeeded); +void print_VkSubpassSampleLocationsEXT(const VkSubpassSampleLocationsEXT* obj, const char* str, int commaNeeded); +void print_VkRenderPassSampleLocationsBeginInfoEXT(const VkRenderPassSampleLocationsBeginInfoEXT* obj, const char* str, int commaNeeded); +void print_VkPipelineSampleLocationsStateCreateInfoEXT(const VkPipelineSampleLocationsStateCreateInfoEXT* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceSampleLocationsPropertiesEXT(const VkPhysicalDeviceSampleLocationsPropertiesEXT* obj, const char* str, int commaNeeded); +void print_VkMultisamplePropertiesEXT(const VkMultisamplePropertiesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_2 +void print_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_blend_operation_advanced +void print_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* obj, const char* str, int commaNeeded); +void print_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const VkPipelineColorBlendAdvancedStateCreateInfoEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_2 +void print_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_1 +void print_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties* obj, const char* str, int commaNeeded); +void print_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceShaderDrawParameterFeatures(const VkPhysicalDeviceShaderDrawParameterFeatures* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_global_priority +void print_VkDeviceQueueGlobalPriorityCreateInfoEXT(const VkDeviceQueueGlobalPriorityCreateInfoEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_debug_utils +void print_VkDebugUtilsObjectNameInfoEXT(const VkDebugUtilsObjectNameInfoEXT* obj, const char* str, int commaNeeded); +void print_VkDebugUtilsObjectTagInfoEXT(const VkDebugUtilsObjectTagInfoEXT* obj, const char* str, int commaNeeded); +void print_VkDebugUtilsLabelEXT(const VkDebugUtilsLabelEXT* obj, const char* str, int commaNeeded); +void print_VkDebugUtilsMessengerCreateInfoEXT(const VkDebugUtilsMessengerCreateInfoEXT* obj, const char* str, int commaNeeded); +void print_VkDebugUtilsMessengerCallbackDataEXT(const VkDebugUtilsMessengerCallbackDataEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_external_memory_host +void print_VkImportMemoryHostPointerInfoEXT(const VkImportMemoryHostPointerInfoEXT* obj, const char* str, int commaNeeded); +void print_VkMemoryHostPointerPropertiesEXT(const VkMemoryHostPointerPropertiesEXT* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_conservative_rasterization +void print_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_calibrated_timestamps +void print_VkCalibratedTimestampInfoEXT(const VkCalibratedTimestampInfoEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_conservative_rasterization +void print_VkPipelineRasterizationConservativeStateCreateInfoEXT(const VkPipelineRasterizationConservativeStateCreateInfoEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties* obj, const char* str, int commaNeeded); +void print_VkDescriptorSetLayoutBindingFlagsCreateInfo(const VkDescriptorSetLayoutBindingFlagsCreateInfo* obj, const char* str, int commaNeeded); +void print_VkDescriptorSetVariableDescriptorCountAllocateInfo(const VkDescriptorSetVariableDescriptorCountAllocateInfo* obj, const char* str, int commaNeeded); +void print_VkDescriptorSetVariableDescriptorCountLayoutSupport(const VkDescriptorSetVariableDescriptorCountLayoutSupport* obj, const char* str, int commaNeeded); +void print_VkAttachmentDescription2(const VkAttachmentDescription2* obj, const char* str, int commaNeeded); +void print_VkAttachmentReference2(const VkAttachmentReference2* obj, const char* str, int commaNeeded); +void print_VkSubpassDescription2(const VkSubpassDescription2* obj, const char* str, int commaNeeded); +void print_VkSubpassDependency2(const VkSubpassDependency2* obj, const char* str, int commaNeeded); +void print_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2* obj, const char* str, int commaNeeded); +void print_VkSubpassBeginInfo(const VkSubpassBeginInfo* obj, const char* str, int commaNeeded); +void print_VkSubpassEndInfo(const VkSubpassEndInfo* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties* obj, const char* str, int commaNeeded); +void print_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo* obj, const char* str, int commaNeeded); +void print_VkTimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo* obj, const char* str, int commaNeeded); +void print_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo* obj, const char* str, int commaNeeded); +void print_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_vertex_attribute_divisor +void print_VkVertexInputBindingDivisorDescriptionEXT(const VkVertexInputBindingDivisorDescriptionEXT* obj, const char* str, int commaNeeded); +void print_VkPipelineVertexInputDivisorStateCreateInfoEXT(const VkPipelineVertexInputDivisorStateCreateInfoEXT* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_pci_bus_info +void print_VkPhysicalDevicePCIBusInfoPropertiesEXT(const VkPhysicalDevicePCIBusInfoPropertiesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_shader_atomic_float +void print_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_vertex_attribute_divisor +void print_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties* obj, const char* str, int commaNeeded); +void print_VkSubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_astc_decode_mode +void print_VkImageViewASTCDecodeModeEXT(const VkImageViewASTCDecodeModeEXT* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceASTCDecodeFeaturesEXT(const VkPhysicalDeviceASTCDecodeFeaturesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_image_drm_format_modifier +void print_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT* obj, const char* str, int commaNeeded); +void print_VkDrmFormatModifierPropertiesEXT(const VkDrmFormatModifierPropertiesEXT* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* obj, const char* str, int commaNeeded); +void print_VkImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT* obj, const char* str, int commaNeeded); +void print_VkImageDrmFormatModifierExplicitCreateInfoEXT(const VkImageDrmFormatModifierExplicitCreateInfoEXT* obj, const char* str, int commaNeeded); +void print_VkImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_2 +void print_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_depth_clip_enable +void print_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const VkPhysicalDeviceDepthClipEnableFeaturesEXT* obj, const char* str, int commaNeeded); +void print_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const VkPipelineRasterizationDepthClipStateCreateInfoEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_memory_budget +void print_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const VkPhysicalDeviceMemoryBudgetPropertiesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures* obj, const char* str, int commaNeeded); +void print_VkBufferDeviceAddressInfo(const VkBufferDeviceAddressInfo* obj, const char* str, int commaNeeded); +void print_VkBufferOpaqueCaptureAddressCreateInfo(const VkBufferOpaqueCaptureAddressCreateInfo* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_filter_cubic +void print_VkPhysicalDeviceImageViewImageFormatInfoEXT(const VkPhysicalDeviceImageViewImageFormatInfoEXT* obj, const char* str, int commaNeeded); +void print_VkFilterCubicImageViewImageFormatPropertiesEXT(const VkFilterCubicImageViewImageFormatPropertiesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures* obj, const char* str, int commaNeeded); +void print_VkFramebufferAttachmentsCreateInfo(const VkFramebufferAttachmentsCreateInfo* obj, const char* str, int commaNeeded); +void print_VkFramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo* obj, const char* str, int commaNeeded); +void print_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_texture_compression_astc_hdr +void print_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_ycbcr_image_arrays +void print_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_performance_query +void print_VkPhysicalDevicePerformanceQueryFeaturesKHR(const VkPhysicalDevicePerformanceQueryFeaturesKHR* obj, const char* str, int commaNeeded); +void print_VkPhysicalDevicePerformanceQueryPropertiesKHR(const VkPhysicalDevicePerformanceQueryPropertiesKHR* obj, const char* str, int commaNeeded); +void print_VkPerformanceCounterKHR(const VkPerformanceCounterKHR* obj, const char* str, int commaNeeded); +void print_VkPerformanceCounterDescriptionKHR(const VkPerformanceCounterDescriptionKHR* obj, const char* str, int commaNeeded); +void print_VkQueryPoolPerformanceCreateInfoKHR(const VkQueryPoolPerformanceCreateInfoKHR* obj, const char* str, int commaNeeded); +void print_VkAcquireProfilingLockInfoKHR(const VkAcquireProfilingLockInfoKHR* obj, const char* str, int commaNeeded); +void print_VkPerformanceQuerySubmitInfoKHR(const VkPerformanceQuerySubmitInfoKHR* obj, const char* str, int commaNeeded); +void print_VkPerformanceQueryReservationInfoKHR(const VkPerformanceQueryReservationInfoKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_headless_surface +void print_VkHeadlessSurfaceCreateInfoEXT(const VkHeadlessSurfaceCreateInfoEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_shader_clock +void print_VkPhysicalDeviceShaderClockFeaturesKHR(const VkPhysicalDeviceShaderClockFeaturesKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_index_type_uint8 +void print_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_fragment_shader_interlock +void print_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* obj, const char* str, int commaNeeded); +void print_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout* obj, const char* str, int commaNeeded); +void print_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_shader_demote_to_helper_invocation +void print_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_texel_buffer_alignment +void print_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_subgroup_size_control +void print_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* obj, const char* str, int commaNeeded); +void print_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_2 +void print_VkMemoryOpaqueCaptureAddressAllocateInfo(const VkMemoryOpaqueCaptureAddressAllocateInfo* obj, const char* str, int commaNeeded); +void print_VkDeviceMemoryOpaqueCaptureAddressInfo(const VkDeviceMemoryOpaqueCaptureAddressInfo* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_line_rasterization +void print_VkPhysicalDeviceLineRasterizationFeaturesEXT(const VkPhysicalDeviceLineRasterizationFeaturesEXT* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceLineRasterizationPropertiesEXT(const VkPhysicalDeviceLineRasterizationPropertiesEXT* obj, const char* str, int commaNeeded); +void print_VkPipelineRasterizationLineStateCreateInfoEXT(const VkPipelineRasterizationLineStateCreateInfoEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_VERSION_1_2 +void print_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties* obj, const char* str, int commaNeeded); +#endif +#ifdef VKSC_VERSION_1_0 +void print_VkFaultData(const VkFaultData* obj, const char* str, int commaNeeded); +void print_VkFaultCallbackInfo(const VkFaultCallbackInfo* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_custom_border_color +void print_VkSamplerCustomBorderColorCreateInfoEXT(const VkSamplerCustomBorderColorCreateInfoEXT* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const VkPhysicalDeviceCustomBorderColorPropertiesEXT* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const VkPhysicalDeviceCustomBorderColorFeaturesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_object_refresh +void print_VkRefreshObjectKHR(const VkRefreshObjectKHR* obj, const char* str, int commaNeeded); +void print_VkRefreshObjectListKHR(const VkRefreshObjectListKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_extended_dynamic_state +void print_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_extended_dynamic_state2 +void print_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VKSC_VERSION_1_0 +void print_VkPipelineOfflineCreateInfo(const VkPipelineOfflineCreateInfo* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_robustness2 +void print_VkPhysicalDeviceRobustness2FeaturesEXT(const VkPhysicalDeviceRobustness2FeaturesEXT* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceRobustness2PropertiesEXT(const VkPhysicalDeviceRobustness2PropertiesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_image_robustness +void print_VkPhysicalDeviceImageRobustnessFeaturesEXT(const VkPhysicalDeviceImageRobustnessFeaturesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_4444_formats +void print_VkPhysicalDevice4444FormatsFeaturesEXT(const VkPhysicalDevice4444FormatsFeaturesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_copy_commands2 +void print_VkBufferCopy2KHR(const VkBufferCopy2KHR* obj, const char* str, int commaNeeded); +void print_VkImageCopy2KHR(const VkImageCopy2KHR* obj, const char* str, int commaNeeded); +void print_VkImageBlit2KHR(const VkImageBlit2KHR* obj, const char* str, int commaNeeded); +void print_VkBufferImageCopy2KHR(const VkBufferImageCopy2KHR* obj, const char* str, int commaNeeded); +void print_VkImageResolve2KHR(const VkImageResolve2KHR* obj, const char* str, int commaNeeded); +void print_VkCopyBufferInfo2KHR(const VkCopyBufferInfo2KHR* obj, const char* str, int commaNeeded); +void print_VkCopyImageInfo2KHR(const VkCopyImageInfo2KHR* obj, const char* str, int commaNeeded); +void print_VkBlitImageInfo2KHR(const VkBlitImageInfo2KHR* obj, const char* str, int commaNeeded); +void print_VkCopyBufferToImageInfo2KHR(const VkCopyBufferToImageInfo2KHR* obj, const char* str, int commaNeeded); +void print_VkCopyImageToBufferInfo2KHR(const VkCopyImageToBufferInfo2KHR* obj, const char* str, int commaNeeded); +void print_VkResolveImageInfo2KHR(const VkResolveImageInfo2KHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_shader_image_atomic_int64 +void print_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_fragment_shading_rate +void print_VkFragmentShadingRateAttachmentInfoKHR(const VkFragmentShadingRateAttachmentInfoKHR* obj, const char* str, int commaNeeded); +void print_VkPipelineFragmentShadingRateStateCreateInfoKHR(const VkPipelineFragmentShadingRateStateCreateInfoKHR* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceFragmentShadingRateKHR(const VkPhysicalDeviceFragmentShadingRateKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_shader_terminate_invocation +void print_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_vertex_input_dynamic_state +void print_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* obj, const char* str, int commaNeeded); +void print_VkVertexInputBindingDescription2EXT(const VkVertexInputBindingDescription2EXT* obj, const char* str, int commaNeeded); +void print_VkVertexInputAttributeDescription2EXT(const VkVertexInputAttributeDescription2EXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_color_write_enable +void print_VkPhysicalDeviceColorWriteEnableFeaturesEXT(const VkPhysicalDeviceColorWriteEnableFeaturesEXT* obj, const char* str, int commaNeeded); +void print_VkPipelineColorWriteCreateInfoEXT(const VkPipelineColorWriteCreateInfoEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_KHR_synchronization2 +void print_VkMemoryBarrier2KHR(const VkMemoryBarrier2KHR* obj, const char* str, int commaNeeded); +void print_VkImageMemoryBarrier2KHR(const VkImageMemoryBarrier2KHR* obj, const char* str, int commaNeeded); +void print_VkBufferMemoryBarrier2KHR(const VkBufferMemoryBarrier2KHR* obj, const char* str, int commaNeeded); +void print_VkDependencyInfoKHR(const VkDependencyInfoKHR* obj, const char* str, int commaNeeded); +void print_VkSemaphoreSubmitInfoKHR(const VkSemaphoreSubmitInfoKHR* obj, const char* str, int commaNeeded); +void print_VkCommandBufferSubmitInfoKHR(const VkCommandBufferSubmitInfoKHR* obj, const char* str, int commaNeeded); +void print_VkSubmitInfo2KHR(const VkSubmitInfo2KHR* obj, const char* str, int commaNeeded); +void print_VkQueueFamilyCheckpointProperties2NV(const VkQueueFamilyCheckpointProperties2NV* obj, const char* str, int commaNeeded); +void print_VkCheckpointData2NV(const VkCheckpointData2NV* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceSynchronization2FeaturesKHR(const VkPhysicalDeviceSynchronization2FeaturesKHR* obj, const char* str, int commaNeeded); +#endif +#ifdef VKSC_VERSION_1_0 +void print_VkPhysicalDeviceVulkanSC10Properties(const VkPhysicalDeviceVulkanSC10Properties* obj, const char* str, int commaNeeded); +void print_VkPipelinePoolSize(const VkPipelinePoolSize* obj, const char* str, int commaNeeded); +void print_VkDeviceObjectReservationCreateInfo(const VkDeviceObjectReservationCreateInfo* obj, const char* str, int commaNeeded); +void print_VkCommandPoolMemoryReservationCreateInfo(const VkCommandPoolMemoryReservationCreateInfo* obj, const char* str, int commaNeeded); +void print_VkCommandPoolMemoryConsumption(const VkCommandPoolMemoryConsumption* obj, const char* str, int commaNeeded); +void print_VkPhysicalDeviceVulkanSC10Features(const VkPhysicalDeviceVulkanSC10Features* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_ycbcr_2plane_444_formats +void print_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* obj, const char* str, int commaNeeded); +#endif +#ifdef VK_EXT_image_drm_format_modifier +void print_VkDrmFormatModifierPropertiesList2EXT(const VkDrmFormatModifierPropertiesList2EXT* obj, const char* str, int commaNeeded); +void print_VkDrmFormatModifierProperties2EXT(const VkDrmFormatModifierProperties2EXT* obj, const char* str, int commaNeeded); +#endif +/*************************************** End prototypes ***********************************/ + + +void dumpPNextChain(const void* pNext); + diff --git a/json/vulkan_json_parser.hpp b/json/vulkan_json_parser.hpp new file mode 100644 index 0000000..5e403d1 --- /dev/null +++ b/json/vulkan_json_parser.hpp @@ -0,0 +1,14346 @@ +#ifndef _VULKAN_JSON_PARSER_HPP +#define _VULKAN_JSON_PARSER_HPP + +/* + * Copyright (c) 2021 The Khronos Group Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + *//*! + * \file + * \brief Defines JSON generators for Vulkan structures + */ + + +/********************************************************************************************/ +/** This code is generated. To make changes, please modify the scripts or the relevant xml **/ +/********************************************************************************************/ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace vk_json_parser { + +template +class GlobalMem { + void grow() { + //push_back new single vector of size m_tabSize onto vec + void * p = calloc(m_tabSize, sizeof(T2)); + assert(p); + m_vec.push_back(p); + m_pointer = 0U; + } + void * alloc(T1 size) { + void* result = static_cast(m_vec.back()) + m_pointer; + m_pointer += size; + return result; + } +public: + + GlobalMem(T1 tabSize_ = 32768U) + : m_tabSize(tabSize_), m_pointer(0U) + { + grow(); + } + + void* allocate (T1 size) + { + if (m_pointer+size >= m_tabSize) { + grow(); + } + return alloc(size); + } + + void* allocate (T1 count, T1 size) + { + T1 totalSize = count * size; + if (m_pointer+totalSize >= m_tabSize) + { + grow(); + } + return alloc(totalSize); + } + // deallocates all memory. Any use of earlier allocated elements is forbidden + void clear() + { + // remove all vectors from vec excluding the one with index 0 + for (size_t i=1 ; i m_vec; + T1 m_tabSize; + T1 m_pointer; +}; + +#if defined(USE_THREAD_LOCAL_WAR) +// Workaround (off by default) for certain platforms that have a thread_local libc bug +vk_json_parser::GlobalMem & TLSGetGlobalMem(); +#define s_globalMem TLSGetGlobalMem() +#else +static thread_local GlobalMem s_globalMem(32768U); +#endif + +// To make sure the generated data is consistent across platforms, +// we typecast to 32-bit. +static void parse_size_t(const char* s, Json::Value& obj, size_t& o) +{ + uint32_t _res = static_cast(obj.asUInt()); + o = _res; +} + +static void parse_char(const char* s, Json::Value& obj, char o[]) +{ + std::string _res = obj.asString(); + memcpy((void*)o, _res.c_str(), static_cast(_res.size())); + o[_res.size()] = '\0'; +} +static void parse_char(const char* s, Json::Value& obj, const char* const*) +{ +} +static void parse_char(const char* s, Json::Value& obj, const char** o) +{ + std::string _res = obj.asString(); + char** writePtr = (char**)o; + *writePtr = (char *)s_globalMem.allocate(static_cast(_res.size()) + 1); + memcpy((void*)*writePtr, _res.c_str(), _res.size()); + (*writePtr)[_res.size()] = '\0'; +} + + +static void parse_int32_t(const char* s, Json::Value& obj, int32_t& o) +{ + o = obj.asInt(); +} + +static void parse_uint32_t(const char* s, Json::Value& obj, uint32_t& o) +{ + if (obj.isString()) + if (obj.asString() == "VK_MAX_PHYSICAL_DEVICE_NAME_SIZE") + o = 256; + else if (obj.asString() == "VK_UUID_SIZE") + o = 16; + else if (obj.asString() == "VK_LUID_SIZE") + o = 8; + else if (obj.asString() == "VK_MAX_EXTENSION_NAME_SIZE") + o = 256; + else if (obj.asString() == "VK_MAX_DESCRIPTION_SIZE") + o = 256; + else if (obj.asString() == "VK_MAX_MEMORY_TYPES") + o = 32; + else if (obj.asString() == "VK_MAX_MEMORY_HEAPS") + o = 16; + else if (obj.asString() == "VK_REMAINING_MIP_LEVELS") + o = (~0U); + else if (obj.asString() == "VK_REMAINING_ARRAY_LAYERS") + o = (~0U); + else if (obj.asString() == "VK_ATTACHMENT_UNUSED") + o = (~0U); + else if (obj.asString() == "VK_TRUE") + o = 1; + else if (obj.asString() == "VK_FALSE") + o = 0; + else if (obj.asString() == "VK_QUEUE_FAMILY_IGNORED") + o = (~0U); + else if (obj.asString() == "VK_QUEUE_FAMILY_EXTERNAL") + o = (~1U); + else if (obj.asString() == "VK_QUEUE_FAMILY_FOREIGN_EXT") + o = (~2U); + else if (obj.asString() == "VK_SUBPASS_EXTERNAL") + o = (~0U); + else if (obj.asString() == "VK_MAX_DEVICE_GROUP_SIZE") + o = 32; + else if (obj.asString() == "VK_MAX_DRIVER_NAME_SIZE") + o = 256; + else if (obj.asString() == "VK_MAX_DRIVER_INFO_SIZE") + o = 256; + else if (obj.asString() == "VK_SHADER_UNUSED_KHR") + o = (~0U); + else if (obj.asString() == "VK_MAX_GLOBAL_PRIORITY_SIZE_EXT") + o = 16; + else + assert(false); + else + o = obj.asUInt(); +} + +static void parse_uint8_t(const char* s, Json::Value& obj, uint8_t& o) +{ + o = static_cast(obj.asUInt()); +} + +static void parse_uint64_t(const char* s, Json::Value& obj, uint64_t& o) +{ + if (obj.isString()) + if (obj.asString() == "VK_WHOLE_SIZE") + o = (~0ULL); + else + assert(false); + else + o = obj.asUInt64(); +} + +static void parse_float(const char* s, Json::Value& obj, float& o) +{ + if (obj.isString()) + if (obj.asString() == "VK_LOD_CLAMP_NONE") + o = 1000.0F; + else if (obj.asString() == "NaN") + o = std::numeric_limits::quiet_NaN(); + else + assert(false); + else + o = obj.asFloat(); +} + +static void parse_int(const char* s, Json::Value& obj, int& o) +{ + o = obj.asInt(); +} + +static void parse_double(const char* s, Json::Value& obj, double& o) +{ + o = obj.asDouble(); +} + +static void parse_int64_t(const char* s, Json::Value& obj, int64_t& o) +{ + o = obj.asInt64(); +} + +static void parse_uint16_t(const char* s, Json::Value& obj, uint16_t& o) +{ + o = static_cast(obj.asUInt()); +} + + +// base64 encoder taken from executor/xeTestResultParser.cpp + +static +std::vector base64decode(const std::string encoded) +{ + int base64DecodeOffset = 0; + std::vector result; + + for (std::size_t inNdx = 0; inNdx < encoded.size(); inNdx++) + { + uint8_t byte = encoded[inNdx]; + uint8_t decodedBits = 0; + + if ('A' <= byte && byte <= 'Z') + decodedBits = (uint8_t)(byte - 'A'); + else if ('a' <= byte && byte <= 'z') + decodedBits = (uint8_t)(('Z' - 'A' + 1) + (byte - 'a')); + else if ('0' <= byte && byte <= '9') + decodedBits = (uint8_t)(('Z' - 'A' + 1) + ('z' - 'a' + 1) + (byte - '0')); + else if (byte == '+') + decodedBits = ('Z' - 'A' + 1) + ('z' - 'a' + 1) + ('9' - '0' + 1); + else if (byte == '/') + decodedBits = ('Z' - 'A' + 1) + ('z' - 'a' + 1) + ('9' - '0' + 2); + else + continue; // Not an B64 input character. + + int phase = base64DecodeOffset % 4; + + if (phase == 0) + result.resize(result.size() + 3, 0); + + // if ((int)image->data.size() < (base64DecodeOffset >> 2) * 3 + 3) + // throw TestResultParseError("Malformed base64 data"); + uint8_t* outPtr = result.data() + (base64DecodeOffset >> 2) * 3; + + switch (phase) + { + case 0: outPtr[0] |= (uint8_t)(decodedBits << 2); break; + case 1: outPtr[0] = (uint8_t)(outPtr[0] | (uint8_t)(decodedBits >> 4)); outPtr[1] = (uint8_t)(outPtr[1] | (uint8_t)((decodedBits & 0xF) << 4)); break; + case 2: outPtr[1] = (uint8_t)(outPtr[1] | (uint8_t)(decodedBits >> 2)); outPtr[2] = (uint8_t)(outPtr[2] | (uint8_t)((decodedBits & 0x3) << 6)); break; + case 3: outPtr[2] |= decodedBits; break; + default: + assert(false); + } + + base64DecodeOffset++; + } + return result; +} + +static void parse_void_data(const void* s, Json::Value& obj, void* o, int oSize) +{ + std::vector data = base64decode(obj.asString()); + memcpy(o, data.data(), oSize); +} + + +/*************************************** Begin prototypes ***********************************/ +static void parse_VkSampleMask(const char* s, Json::Value& obj, VkSampleMask& o); +static void parse_VkBool32(const char* s, Json::Value& obj, VkBool32& o); +static void parse_VkFlags(const char* s, Json::Value& obj, VkFlags& o); +#ifdef VK_KHR_synchronization2 +static void parse_VkFlags64(const char* s, Json::Value& obj, VkFlags64& o); +#endif +static void parse_VkDeviceSize(const char* s, Json::Value& obj, VkDeviceSize& o); +static void parse_VkDeviceAddress(const char* s, Json::Value& obj, VkDeviceAddress& o); +static void parse_VkFramebufferCreateFlags(const char* s, Json::Value& obj, VkFramebufferCreateFlags& o); +static void parse_VkQueryPoolCreateFlags(const char* s, Json::Value& obj, VkQueryPoolCreateFlags& o); +static void parse_VkRenderPassCreateFlags(const char* s, Json::Value& obj, VkRenderPassCreateFlags& o); +static void parse_VkSamplerCreateFlags(const char* s, Json::Value& obj, VkSamplerCreateFlags& o); +static void parse_VkPipelineLayoutCreateFlags(const char* s, Json::Value& obj, VkPipelineLayoutCreateFlags& o); +static void parse_VkPipelineCacheCreateFlags(const char* s, Json::Value& obj, VkPipelineCacheCreateFlags& o); +static void parse_VkPipelineDepthStencilStateCreateFlags(const char* s, Json::Value& obj, VkPipelineDepthStencilStateCreateFlags& o); +static void parse_VkPipelineDynamicStateCreateFlags(const char* s, Json::Value& obj, VkPipelineDynamicStateCreateFlags& o); +static void parse_VkPipelineColorBlendStateCreateFlags(const char* s, Json::Value& obj, VkPipelineColorBlendStateCreateFlags& o); +static void parse_VkPipelineMultisampleStateCreateFlags(const char* s, Json::Value& obj, VkPipelineMultisampleStateCreateFlags& o); +static void parse_VkPipelineRasterizationStateCreateFlags(const char* s, Json::Value& obj, VkPipelineRasterizationStateCreateFlags& o); +static void parse_VkPipelineViewportStateCreateFlags(const char* s, Json::Value& obj, VkPipelineViewportStateCreateFlags& o); +static void parse_VkPipelineTessellationStateCreateFlags(const char* s, Json::Value& obj, VkPipelineTessellationStateCreateFlags& o); +static void parse_VkPipelineInputAssemblyStateCreateFlags(const char* s, Json::Value& obj, VkPipelineInputAssemblyStateCreateFlags& o); +static void parse_VkPipelineVertexInputStateCreateFlags(const char* s, Json::Value& obj, VkPipelineVertexInputStateCreateFlags& o); +static void parse_VkPipelineShaderStageCreateFlags(const char* s, Json::Value& obj, VkPipelineShaderStageCreateFlags& o); +static void parse_VkDescriptorSetLayoutCreateFlags(const char* s, Json::Value& obj, VkDescriptorSetLayoutCreateFlags& o); +static void parse_VkBufferViewCreateFlags(const char* s, Json::Value& obj, VkBufferViewCreateFlags& o); +static void parse_VkInstanceCreateFlags(const char* s, Json::Value& obj, VkInstanceCreateFlags& o); +static void parse_VkDeviceCreateFlags(const char* s, Json::Value& obj, VkDeviceCreateFlags& o); +static void parse_VkDeviceQueueCreateFlags(const char* s, Json::Value& obj, VkDeviceQueueCreateFlags& o); +static void parse_VkQueueFlags(const char* s, Json::Value& obj, VkQueueFlags& o); +static void parse_VkMemoryPropertyFlags(const char* s, Json::Value& obj, VkMemoryPropertyFlags& o); +static void parse_VkMemoryHeapFlags(const char* s, Json::Value& obj, VkMemoryHeapFlags& o); +static void parse_VkAccessFlags(const char* s, Json::Value& obj, VkAccessFlags& o); +static void parse_VkBufferUsageFlags(const char* s, Json::Value& obj, VkBufferUsageFlags& o); +static void parse_VkBufferCreateFlags(const char* s, Json::Value& obj, VkBufferCreateFlags& o); +static void parse_VkShaderStageFlags(const char* s, Json::Value& obj, VkShaderStageFlags& o); +static void parse_VkImageUsageFlags(const char* s, Json::Value& obj, VkImageUsageFlags& o); +static void parse_VkImageCreateFlags(const char* s, Json::Value& obj, VkImageCreateFlags& o); +static void parse_VkImageViewCreateFlags(const char* s, Json::Value& obj, VkImageViewCreateFlags& o); +static void parse_VkPipelineCreateFlags(const char* s, Json::Value& obj, VkPipelineCreateFlags& o); +static void parse_VkColorComponentFlags(const char* s, Json::Value& obj, VkColorComponentFlags& o); +static void parse_VkFenceCreateFlags(const char* s, Json::Value& obj, VkFenceCreateFlags& o); +static void parse_VkSemaphoreCreateFlags(const char* s, Json::Value& obj, VkSemaphoreCreateFlags& o); +static void parse_VkFormatFeatureFlags(const char* s, Json::Value& obj, VkFormatFeatureFlags& o); +static void parse_VkQueryControlFlags(const char* s, Json::Value& obj, VkQueryControlFlags& o); +static void parse_VkQueryResultFlags(const char* s, Json::Value& obj, VkQueryResultFlags& o); +static void parse_VkEventCreateFlags(const char* s, Json::Value& obj, VkEventCreateFlags& o); +static void parse_VkCommandPoolCreateFlags(const char* s, Json::Value& obj, VkCommandPoolCreateFlags& o); +static void parse_VkCommandPoolResetFlags(const char* s, Json::Value& obj, VkCommandPoolResetFlags& o); +static void parse_VkCommandBufferResetFlags(const char* s, Json::Value& obj, VkCommandBufferResetFlags& o); +static void parse_VkCommandBufferUsageFlags(const char* s, Json::Value& obj, VkCommandBufferUsageFlags& o); +static void parse_VkQueryPipelineStatisticFlags(const char* s, Json::Value& obj, VkQueryPipelineStatisticFlags& o); +static void parse_VkMemoryMapFlags(const char* s, Json::Value& obj, VkMemoryMapFlags& o); +static void parse_VkImageAspectFlags(const char* s, Json::Value& obj, VkImageAspectFlags& o); +static void parse_VkSubpassDescriptionFlags(const char* s, Json::Value& obj, VkSubpassDescriptionFlags& o); +static void parse_VkPipelineStageFlags(const char* s, Json::Value& obj, VkPipelineStageFlags& o); +static void parse_VkSampleCountFlags(const char* s, Json::Value& obj, VkSampleCountFlags& o); +static void parse_VkAttachmentDescriptionFlags(const char* s, Json::Value& obj, VkAttachmentDescriptionFlags& o); +static void parse_VkStencilFaceFlags(const char* s, Json::Value& obj, VkStencilFaceFlags& o); +static void parse_VkCullModeFlags(const char* s, Json::Value& obj, VkCullModeFlags& o); +static void parse_VkDescriptorPoolCreateFlags(const char* s, Json::Value& obj, VkDescriptorPoolCreateFlags& o); +static void parse_VkDescriptorPoolResetFlags(const char* s, Json::Value& obj, VkDescriptorPoolResetFlags& o); +static void parse_VkDependencyFlags(const char* s, Json::Value& obj, VkDependencyFlags& o); +#ifdef VK_VERSION_1_1 +static void parse_VkSubgroupFeatureFlags(const char* s, Json::Value& obj, VkSubgroupFeatureFlags& o); +#endif +#ifdef VK_KHR_performance_query +static void parse_VkPerformanceCounterDescriptionFlagsKHR(const char* s, Json::Value& obj, VkPerformanceCounterDescriptionFlagsKHR& o); +static void parse_VkAcquireProfilingLockFlagsKHR(const char* s, Json::Value& obj, VkAcquireProfilingLockFlagsKHR& o); +#endif +#ifdef VK_VERSION_1_2 +static void parse_VkSemaphoreWaitFlags(const char* s, Json::Value& obj, VkSemaphoreWaitFlags& o); +#endif +#ifdef VK_KHR_object_refresh +static void parse_VkRefreshObjectFlagsKHR(const char* s, Json::Value& obj, VkRefreshObjectFlagsKHR& o); +#endif +#ifdef VK_KHR_synchronization2 +static void parse_VkAccessFlags2KHR(const char* s, Json::Value& obj, VkAccessFlags2KHR& o); +static void parse_VkPipelineStageFlags2KHR(const char* s, Json::Value& obj, VkPipelineStageFlags2KHR& o); +#endif +#ifdef VK_KHR_surface +static void parse_VkCompositeAlphaFlagsKHR(const char* s, Json::Value& obj, VkCompositeAlphaFlagsKHR& o); +#endif +#ifdef VK_KHR_display +static void parse_VkDisplayPlaneAlphaFlagsKHR(const char* s, Json::Value& obj, VkDisplayPlaneAlphaFlagsKHR& o); +static void parse_VkSurfaceTransformFlagsKHR(const char* s, Json::Value& obj, VkSurfaceTransformFlagsKHR& o); +#endif +#ifdef VK_KHR_swapchain +static void parse_VkSwapchainCreateFlagsKHR(const char* s, Json::Value& obj, VkSwapchainCreateFlagsKHR& o); +#endif +#ifdef VK_KHR_display +static void parse_VkDisplayModeCreateFlagsKHR(const char* s, Json::Value& obj, VkDisplayModeCreateFlagsKHR& o); +static void parse_VkDisplaySurfaceCreateFlagsKHR(const char* s, Json::Value& obj, VkDisplaySurfaceCreateFlagsKHR& o); +#endif +#ifdef VK_EXT_headless_surface +static void parse_VkHeadlessSurfaceCreateFlagsEXT(const char* s, Json::Value& obj, VkHeadlessSurfaceCreateFlagsEXT& o); +#endif +#ifdef VK_VERSION_1_1 +static void parse_VkPeerMemoryFeatureFlags(const char* s, Json::Value& obj, VkPeerMemoryFeatureFlags& o); +static void parse_VkMemoryAllocateFlags(const char* s, Json::Value& obj, VkMemoryAllocateFlags& o); +#endif +#ifdef VK_KHR_swapchain +static void parse_VkDeviceGroupPresentModeFlagsKHR(const char* s, Json::Value& obj, VkDeviceGroupPresentModeFlagsKHR& o); +#endif +#ifdef VK_VERSION_1_1 +static void parse_VkExternalMemoryHandleTypeFlags(const char* s, Json::Value& obj, VkExternalMemoryHandleTypeFlags& o); +static void parse_VkExternalMemoryFeatureFlags(const char* s, Json::Value& obj, VkExternalMemoryFeatureFlags& o); +static void parse_VkExternalSemaphoreHandleTypeFlags(const char* s, Json::Value& obj, VkExternalSemaphoreHandleTypeFlags& o); +static void parse_VkExternalSemaphoreFeatureFlags(const char* s, Json::Value& obj, VkExternalSemaphoreFeatureFlags& o); +static void parse_VkSemaphoreImportFlags(const char* s, Json::Value& obj, VkSemaphoreImportFlags& o); +static void parse_VkExternalFenceHandleTypeFlags(const char* s, Json::Value& obj, VkExternalFenceHandleTypeFlags& o); +static void parse_VkExternalFenceFeatureFlags(const char* s, Json::Value& obj, VkExternalFenceFeatureFlags& o); +static void parse_VkFenceImportFlags(const char* s, Json::Value& obj, VkFenceImportFlags& o); +#endif +#ifdef VK_EXT_display_surface_counter +static void parse_VkSurfaceCounterFlagsEXT(const char* s, Json::Value& obj, VkSurfaceCounterFlagsEXT& o); +#endif +#ifdef VK_EXT_discard_rectangles +static void parse_VkPipelineDiscardRectangleStateCreateFlagsEXT(const char* s, Json::Value& obj, VkPipelineDiscardRectangleStateCreateFlagsEXT& o); +#endif +#ifdef VK_EXT_debug_utils +static void parse_VkDebugUtilsMessageSeverityFlagsEXT(const char* s, Json::Value& obj, VkDebugUtilsMessageSeverityFlagsEXT& o); +static void parse_VkDebugUtilsMessageTypeFlagsEXT(const char* s, Json::Value& obj, VkDebugUtilsMessageTypeFlagsEXT& o); +static void parse_VkDebugUtilsMessengerCreateFlagsEXT(const char* s, Json::Value& obj, VkDebugUtilsMessengerCreateFlagsEXT& o); +static void parse_VkDebugUtilsMessengerCallbackDataFlagsEXT(const char* s, Json::Value& obj, VkDebugUtilsMessengerCallbackDataFlagsEXT& o); +#endif +#ifdef VK_EXT_conservative_rasterization +static void parse_VkPipelineRasterizationConservativeStateCreateFlagsEXT(const char* s, Json::Value& obj, VkPipelineRasterizationConservativeStateCreateFlagsEXT& o); +#endif +#ifdef VK_VERSION_1_2 +static void parse_VkDescriptorBindingFlags(const char* s, Json::Value& obj, VkDescriptorBindingFlags& o); +static void parse_VkResolveModeFlags(const char* s, Json::Value& obj, VkResolveModeFlags& o); +#endif +#ifdef VK_EXT_depth_clip_enable +static void parse_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(const char* s, Json::Value& obj, VkPipelineRasterizationDepthClipStateCreateFlagsEXT& o); +#endif +#ifdef VK_KHR_synchronization2 +static void parse_VkSubmitFlagsKHR(const char* s, Json::Value& obj, VkSubmitFlagsKHR& o); +#endif +static void parse_VkInstance(const char* s, Json::Value& obj, VkInstance& o); +static void parse_VkPhysicalDevice(const char* s, Json::Value& obj, VkPhysicalDevice& o); +static void parse_VkDevice(const char* s, Json::Value& obj, VkDevice& o); +static void parse_VkQueue(const char* s, Json::Value& obj, VkQueue& o); +static void parse_VkCommandBuffer(const char* s, Json::Value& obj, VkCommandBuffer& o); +static void parse_VkDeviceMemory(const char* s, Json::Value& obj, VkDeviceMemory& o); +static void parse_VkCommandPool(const char* s, Json::Value& obj, VkCommandPool& o); +static void parse_VkBuffer(const char* s, Json::Value& obj, VkBuffer& o); +static void parse_VkBufferView(const char* s, Json::Value& obj, VkBufferView& o); +static void parse_VkImage(const char* s, Json::Value& obj, VkImage& o); +static void parse_VkImageView(const char* s, Json::Value& obj, VkImageView& o); +static void parse_VkShaderModule(const char* s, Json::Value& obj, VkShaderModule& o); +static void parse_VkPipeline(const char* s, Json::Value& obj, VkPipeline& o); +static void parse_VkPipelineLayout(const char* s, Json::Value& obj, VkPipelineLayout& o); +static void parse_VkSampler(const char* s, Json::Value& obj, VkSampler& o); +static void parse_VkDescriptorSet(const char* s, Json::Value& obj, VkDescriptorSet& o); +static void parse_VkDescriptorSetLayout(const char* s, Json::Value& obj, VkDescriptorSetLayout& o); +static void parse_VkDescriptorPool(const char* s, Json::Value& obj, VkDescriptorPool& o); +static void parse_VkFence(const char* s, Json::Value& obj, VkFence& o); +static void parse_VkSemaphore(const char* s, Json::Value& obj, VkSemaphore& o); +static void parse_VkEvent(const char* s, Json::Value& obj, VkEvent& o); +static void parse_VkQueryPool(const char* s, Json::Value& obj, VkQueryPool& o); +static void parse_VkFramebuffer(const char* s, Json::Value& obj, VkFramebuffer& o); +static void parse_VkRenderPass(const char* s, Json::Value& obj, VkRenderPass& o); +static void parse_VkPipelineCache(const char* s, Json::Value& obj, VkPipelineCache& o); +#ifdef VK_VERSION_1_1 +static void parse_VkSamplerYcbcrConversion(const char* s, Json::Value& obj, VkSamplerYcbcrConversion& o); +#endif +#ifdef VK_KHR_display +static void parse_VkDisplayKHR(const char* s, Json::Value& obj, VkDisplayKHR& o); +static void parse_VkDisplayModeKHR(const char* s, Json::Value& obj, VkDisplayModeKHR& o); +#endif +#ifdef VK_KHR_surface +static void parse_VkSurfaceKHR(const char* s, Json::Value& obj, VkSurfaceKHR& o); +#endif +#ifdef VK_KHR_swapchain +static void parse_VkSwapchainKHR(const char* s, Json::Value& obj, VkSwapchainKHR& o); +#endif +#ifdef VK_EXT_debug_utils +static void parse_VkDebugUtilsMessengerEXT(const char* s, Json::Value& obj, VkDebugUtilsMessengerEXT& o); +#endif +static void parse_VkAttachmentLoadOp(const char* s, Json::Value& obj, VkAttachmentLoadOp& o); +static void parse_VkAttachmentStoreOp(const char* s, Json::Value& obj, VkAttachmentStoreOp& o); +static void parse_VkBlendFactor(const char* s, Json::Value& obj, VkBlendFactor& o); +static void parse_VkBlendOp(const char* s, Json::Value& obj, VkBlendOp& o); +static void parse_VkBorderColor(const char* s, Json::Value& obj, VkBorderColor& o); +static void parse_VkFramebufferCreateFlagBits(const char* s, Json::Value& obj, VkFramebufferCreateFlagBits& o); +static void parse_VkRenderPassCreateFlagBits(const char* s, Json::Value& obj, VkRenderPassCreateFlagBits& o); +static void parse_VkSamplerCreateFlagBits(const char* s, Json::Value& obj, VkSamplerCreateFlagBits& o); +static void parse_VkPipelineCacheHeaderVersion(const char* s, Json::Value& obj, VkPipelineCacheHeaderVersion& o); +#ifdef VKSC_VERSION_1_0 +static void parse_VkPipelineCacheCreateFlagBits(const char* s, Json::Value& obj, VkPipelineCacheCreateFlagBits& o); +#endif +static void parse_VkPipelineShaderStageCreateFlagBits(const char* s, Json::Value& obj, VkPipelineShaderStageCreateFlagBits& o); +static void parse_VkDescriptorSetLayoutCreateFlagBits(const char* s, Json::Value& obj, VkDescriptorSetLayoutCreateFlagBits& o); +#ifdef VK_VERSION_1_1 +static void parse_VkDeviceQueueCreateFlagBits(const char* s, Json::Value& obj, VkDeviceQueueCreateFlagBits& o); +#endif +static void parse_VkBufferCreateFlagBits(const char* s, Json::Value& obj, VkBufferCreateFlagBits& o); +static void parse_VkBufferUsageFlagBits(const char* s, Json::Value& obj, VkBufferUsageFlagBits& o); +static void parse_VkColorComponentFlagBits(const char* s, Json::Value& obj, VkColorComponentFlagBits& o); +static void parse_VkComponentSwizzle(const char* s, Json::Value& obj, VkComponentSwizzle& o); +static void parse_VkCommandPoolCreateFlagBits(const char* s, Json::Value& obj, VkCommandPoolCreateFlagBits& o); +static void parse_VkCommandPoolResetFlagBits(const char* s, Json::Value& obj, VkCommandPoolResetFlagBits& o); +static void parse_VkCommandBufferResetFlagBits(const char* s, Json::Value& obj, VkCommandBufferResetFlagBits& o); +static void parse_VkCommandBufferLevel(const char* s, Json::Value& obj, VkCommandBufferLevel& o); +static void parse_VkCommandBufferUsageFlagBits(const char* s, Json::Value& obj, VkCommandBufferUsageFlagBits& o); +static void parse_VkCompareOp(const char* s, Json::Value& obj, VkCompareOp& o); +static void parse_VkCullModeFlagBits(const char* s, Json::Value& obj, VkCullModeFlagBits& o); +static void parse_VkDescriptorType(const char* s, Json::Value& obj, VkDescriptorType& o); +static void parse_VkDynamicState(const char* s, Json::Value& obj, VkDynamicState& o); +static void parse_VkFenceCreateFlagBits(const char* s, Json::Value& obj, VkFenceCreateFlagBits& o); +static void parse_VkPolygonMode(const char* s, Json::Value& obj, VkPolygonMode& o); +static void parse_VkFormat(const char* s, Json::Value& obj, VkFormat& o); +static void parse_VkFormatFeatureFlagBits(const char* s, Json::Value& obj, VkFormatFeatureFlagBits& o); +static void parse_VkFrontFace(const char* s, Json::Value& obj, VkFrontFace& o); +static void parse_VkImageAspectFlagBits(const char* s, Json::Value& obj, VkImageAspectFlagBits& o); +static void parse_VkImageCreateFlagBits(const char* s, Json::Value& obj, VkImageCreateFlagBits& o); +static void parse_VkImageLayout(const char* s, Json::Value& obj, VkImageLayout& o); +static void parse_VkImageTiling(const char* s, Json::Value& obj, VkImageTiling& o); +static void parse_VkImageType(const char* s, Json::Value& obj, VkImageType& o); +static void parse_VkImageUsageFlagBits(const char* s, Json::Value& obj, VkImageUsageFlagBits& o); +static void parse_VkImageViewCreateFlagBits(const char* s, Json::Value& obj, VkImageViewCreateFlagBits& o); +static void parse_VkImageViewType(const char* s, Json::Value& obj, VkImageViewType& o); +static void parse_VkSharingMode(const char* s, Json::Value& obj, VkSharingMode& o); +static void parse_VkIndexType(const char* s, Json::Value& obj, VkIndexType& o); +static void parse_VkLogicOp(const char* s, Json::Value& obj, VkLogicOp& o); +static void parse_VkMemoryHeapFlagBits(const char* s, Json::Value& obj, VkMemoryHeapFlagBits& o); +static void parse_VkAccessFlagBits(const char* s, Json::Value& obj, VkAccessFlagBits& o); +static void parse_VkMemoryPropertyFlagBits(const char* s, Json::Value& obj, VkMemoryPropertyFlagBits& o); +static void parse_VkPhysicalDeviceType(const char* s, Json::Value& obj, VkPhysicalDeviceType& o); +static void parse_VkPipelineBindPoint(const char* s, Json::Value& obj, VkPipelineBindPoint& o); +static void parse_VkPipelineCreateFlagBits(const char* s, Json::Value& obj, VkPipelineCreateFlagBits& o); +static void parse_VkPrimitiveTopology(const char* s, Json::Value& obj, VkPrimitiveTopology& o); +static void parse_VkQueryControlFlagBits(const char* s, Json::Value& obj, VkQueryControlFlagBits& o); +static void parse_VkQueryPipelineStatisticFlagBits(const char* s, Json::Value& obj, VkQueryPipelineStatisticFlagBits& o); +static void parse_VkQueryResultFlagBits(const char* s, Json::Value& obj, VkQueryResultFlagBits& o); +static void parse_VkQueryType(const char* s, Json::Value& obj, VkQueryType& o); +static void parse_VkQueueFlagBits(const char* s, Json::Value& obj, VkQueueFlagBits& o); +static void parse_VkSubpassContents(const char* s, Json::Value& obj, VkSubpassContents& o); +static void parse_VkResult(const char* s, Json::Value& obj, VkResult& o); +static void parse_VkShaderStageFlagBits(const char* s, Json::Value& obj, VkShaderStageFlagBits& o); +static void parse_VkStencilFaceFlagBits(const char* s, Json::Value& obj, VkStencilFaceFlagBits& o); +static void parse_VkStencilOp(const char* s, Json::Value& obj, VkStencilOp& o); +static void parse_VkStructureType(const char* s, Json::Value& obj, VkStructureType& o); +static void parse_VkSystemAllocationScope(const char* s, Json::Value& obj, VkSystemAllocationScope& o); +static void parse_VkInternalAllocationType(const char* s, Json::Value& obj, VkInternalAllocationType& o); +static void parse_VkSamplerAddressMode(const char* s, Json::Value& obj, VkSamplerAddressMode& o); +static void parse_VkFilter(const char* s, Json::Value& obj, VkFilter& o); +static void parse_VkSamplerMipmapMode(const char* s, Json::Value& obj, VkSamplerMipmapMode& o); +static void parse_VkVertexInputRate(const char* s, Json::Value& obj, VkVertexInputRate& o); +static void parse_VkPipelineStageFlagBits(const char* s, Json::Value& obj, VkPipelineStageFlagBits& o); +static void parse_VkSampleCountFlagBits(const char* s, Json::Value& obj, VkSampleCountFlagBits& o); +static void parse_VkAttachmentDescriptionFlagBits(const char* s, Json::Value& obj, VkAttachmentDescriptionFlagBits& o); +static void parse_VkDescriptorPoolCreateFlagBits(const char* s, Json::Value& obj, VkDescriptorPoolCreateFlagBits& o); +static void parse_VkDependencyFlagBits(const char* s, Json::Value& obj, VkDependencyFlagBits& o); +static void parse_VkObjectType(const char* s, Json::Value& obj, VkObjectType& o); +static void parse_VkEventCreateFlagBits(const char* s, Json::Value& obj, VkEventCreateFlagBits& o); +#ifdef VK_EXT_discard_rectangles +static void parse_VkDiscardRectangleModeEXT(const char* s, Json::Value& obj, VkDiscardRectangleModeEXT& o); +#endif +static void parse_VkSubpassDescriptionFlagBits(const char* s, Json::Value& obj, VkSubpassDescriptionFlagBits& o); +#ifdef VK_VERSION_1_1 +static void parse_VkPointClippingBehavior(const char* s, Json::Value& obj, VkPointClippingBehavior& o); +#endif +#ifdef VK_EXT_global_priority +static void parse_VkQueueGlobalPriorityEXT(const char* s, Json::Value& obj, VkQueueGlobalPriorityEXT& o); +#endif +#ifdef VK_EXT_calibrated_timestamps +static void parse_VkTimeDomainEXT(const char* s, Json::Value& obj, VkTimeDomainEXT& o); +#endif +#ifdef VK_EXT_conservative_rasterization +static void parse_VkConservativeRasterizationModeEXT(const char* s, Json::Value& obj, VkConservativeRasterizationModeEXT& o); +#endif +#ifdef VK_VERSION_1_2 +static void parse_VkResolveModeFlagBits(const char* s, Json::Value& obj, VkResolveModeFlagBits& o); +static void parse_VkDescriptorBindingFlagBits(const char* s, Json::Value& obj, VkDescriptorBindingFlagBits& o); +static void parse_VkSemaphoreType(const char* s, Json::Value& obj, VkSemaphoreType& o); +#endif +#ifdef VK_KHR_performance_query +static void parse_VkPerformanceCounterScopeKHR(const char* s, Json::Value& obj, VkPerformanceCounterScopeKHR& o); +static void parse_VkPerformanceCounterUnitKHR(const char* s, Json::Value& obj, VkPerformanceCounterUnitKHR& o); +static void parse_VkPerformanceCounterStorageKHR(const char* s, Json::Value& obj, VkPerformanceCounterStorageKHR& o); +static void parse_VkPerformanceCounterDescriptionFlagBitsKHR(const char* s, Json::Value& obj, VkPerformanceCounterDescriptionFlagBitsKHR& o); +static void parse_VkAcquireProfilingLockFlagBitsKHR(const char* s, Json::Value& obj, VkAcquireProfilingLockFlagBitsKHR& o); +#endif +#ifdef VK_VERSION_1_2 +static void parse_VkSemaphoreWaitFlagBits(const char* s, Json::Value& obj, VkSemaphoreWaitFlagBits& o); +#endif +#ifdef VK_EXT_line_rasterization +static void parse_VkLineRasterizationModeEXT(const char* s, Json::Value& obj, VkLineRasterizationModeEXT& o); +#endif +#ifdef VK_KHR_object_refresh +static void parse_VkRefreshObjectFlagBitsKHR(const char* s, Json::Value& obj, VkRefreshObjectFlagBitsKHR& o); +#endif +#ifdef VKSC_VERSION_1_0 +static void parse_VkFaultLevel(const char* s, Json::Value& obj, VkFaultLevel& o); +static void parse_VkFaultType(const char* s, Json::Value& obj, VkFaultType& o); +static void parse_VkFaultQueryBehavior(const char* s, Json::Value& obj, VkFaultQueryBehavior& o); +static void parse_VkPipelineMatchControl(const char* s, Json::Value& obj, VkPipelineMatchControl& o); +#endif +#ifdef VK_KHR_synchronization2 +static void parse_VkAccessFlagBits2KHR(const char* s, Json::Value& obj, VkAccessFlagBits2KHR& o); +static void parse_VkPipelineStageFlagBits2KHR(const char* s, Json::Value& obj, VkPipelineStageFlagBits2KHR& o); +#endif +#ifdef VKSC_VERSION_1_0 +static void parse_VkPipelineCacheValidationVersion(const char* s, Json::Value& obj, VkPipelineCacheValidationVersion& o); +#endif +#ifdef VK_KHR_surface +static void parse_VkColorSpaceKHR(const char* s, Json::Value& obj, VkColorSpaceKHR& o); +static void parse_VkCompositeAlphaFlagBitsKHR(const char* s, Json::Value& obj, VkCompositeAlphaFlagBitsKHR& o); +#endif +#ifdef VK_KHR_display +static void parse_VkDisplayPlaneAlphaFlagBitsKHR(const char* s, Json::Value& obj, VkDisplayPlaneAlphaFlagBitsKHR& o); +#endif +#ifdef VK_KHR_surface +static void parse_VkPresentModeKHR(const char* s, Json::Value& obj, VkPresentModeKHR& o); +static void parse_VkSurfaceTransformFlagBitsKHR(const char* s, Json::Value& obj, VkSurfaceTransformFlagBitsKHR& o); +#endif +#ifdef VK_EXT_validation_features +static void parse_VkValidationFeatureEnableEXT(const char* s, Json::Value& obj, VkValidationFeatureEnableEXT& o); +static void parse_VkValidationFeatureDisableEXT(const char* s, Json::Value& obj, VkValidationFeatureDisableEXT& o); +#endif +#ifdef VK_VERSION_1_1 +static void parse_VkExternalMemoryHandleTypeFlagBits(const char* s, Json::Value& obj, VkExternalMemoryHandleTypeFlagBits& o); +static void parse_VkExternalMemoryFeatureFlagBits(const char* s, Json::Value& obj, VkExternalMemoryFeatureFlagBits& o); +static void parse_VkExternalSemaphoreHandleTypeFlagBits(const char* s, Json::Value& obj, VkExternalSemaphoreHandleTypeFlagBits& o); +static void parse_VkExternalSemaphoreFeatureFlagBits(const char* s, Json::Value& obj, VkExternalSemaphoreFeatureFlagBits& o); +static void parse_VkSemaphoreImportFlagBits(const char* s, Json::Value& obj, VkSemaphoreImportFlagBits& o); +static void parse_VkExternalFenceHandleTypeFlagBits(const char* s, Json::Value& obj, VkExternalFenceHandleTypeFlagBits& o); +static void parse_VkExternalFenceFeatureFlagBits(const char* s, Json::Value& obj, VkExternalFenceFeatureFlagBits& o); +static void parse_VkFenceImportFlagBits(const char* s, Json::Value& obj, VkFenceImportFlagBits& o); +#endif +#ifdef VK_EXT_display_surface_counter +static void parse_VkSurfaceCounterFlagBitsEXT(const char* s, Json::Value& obj, VkSurfaceCounterFlagBitsEXT& o); +#endif +#ifdef VK_EXT_display_control +static void parse_VkDisplayPowerStateEXT(const char* s, Json::Value& obj, VkDisplayPowerStateEXT& o); +static void parse_VkDeviceEventTypeEXT(const char* s, Json::Value& obj, VkDeviceEventTypeEXT& o); +static void parse_VkDisplayEventTypeEXT(const char* s, Json::Value& obj, VkDisplayEventTypeEXT& o); +#endif +#ifdef VK_VERSION_1_1 +static void parse_VkPeerMemoryFeatureFlagBits(const char* s, Json::Value& obj, VkPeerMemoryFeatureFlagBits& o); +static void parse_VkMemoryAllocateFlagBits(const char* s, Json::Value& obj, VkMemoryAllocateFlagBits& o); +#endif +#ifdef VK_KHR_swapchain +static void parse_VkDeviceGroupPresentModeFlagBitsKHR(const char* s, Json::Value& obj, VkDeviceGroupPresentModeFlagBitsKHR& o); +static void parse_VkSwapchainCreateFlagBitsKHR(const char* s, Json::Value& obj, VkSwapchainCreateFlagBitsKHR& o); +#endif +#ifdef VK_VERSION_1_1 +static void parse_VkSubgroupFeatureFlagBits(const char* s, Json::Value& obj, VkSubgroupFeatureFlagBits& o); +static void parse_VkTessellationDomainOrigin(const char* s, Json::Value& obj, VkTessellationDomainOrigin& o); +static void parse_VkSamplerYcbcrModelConversion(const char* s, Json::Value& obj, VkSamplerYcbcrModelConversion& o); +static void parse_VkSamplerYcbcrRange(const char* s, Json::Value& obj, VkSamplerYcbcrRange& o); +static void parse_VkChromaLocation(const char* s, Json::Value& obj, VkChromaLocation& o); +#endif +#ifdef VK_VERSION_1_2 +static void parse_VkSamplerReductionMode(const char* s, Json::Value& obj, VkSamplerReductionMode& o); +#endif +#ifdef VK_EXT_blend_operation_advanced +static void parse_VkBlendOverlapEXT(const char* s, Json::Value& obj, VkBlendOverlapEXT& o); +#endif +#ifdef VK_EXT_debug_utils +static void parse_VkDebugUtilsMessageSeverityFlagBitsEXT(const char* s, Json::Value& obj, VkDebugUtilsMessageSeverityFlagBitsEXT& o); +static void parse_VkDebugUtilsMessageTypeFlagBitsEXT(const char* s, Json::Value& obj, VkDebugUtilsMessageTypeFlagBitsEXT& o); +#endif +#ifdef VK_VERSION_1_2 +static void parse_VkShaderFloatControlsIndependence(const char* s, Json::Value& obj, VkShaderFloatControlsIndependence& o); +#endif +#ifdef VK_KHR_fragment_shading_rate +static void parse_VkFragmentShadingRateCombinerOpKHR(const char* s, Json::Value& obj, VkFragmentShadingRateCombinerOpKHR& o); +#endif +#ifdef VK_KHR_synchronization2 +static void parse_VkSubmitFlagBitsKHR(const char* s, Json::Value& obj, VkSubmitFlagBitsKHR& o); +#endif +static void parse_VkVendorId(const char* s, Json::Value& obj, VkVendorId& o); +#ifdef VK_VERSION_1_2 +static void parse_VkDriverId(const char* s, Json::Value& obj, VkDriverId& o); +#endif +static void parse_VkBaseOutStructure(const char* s, Json::Value& obj, VkBaseOutStructure& o); +static void parse_VkBaseInStructure(const char* s, Json::Value& obj, VkBaseInStructure& o); +static void parse_VkOffset2D(const char* s, Json::Value& obj, VkOffset2D& o); +static void parse_VkOffset3D(const char* s, Json::Value& obj, VkOffset3D& o); +static void parse_VkExtent2D(const char* s, Json::Value& obj, VkExtent2D& o); +static void parse_VkExtent3D(const char* s, Json::Value& obj, VkExtent3D& o); +static void parse_VkViewport(const char* s, Json::Value& obj, VkViewport& o); +static void parse_VkRect2D(const char* s, Json::Value& obj, VkRect2D& o); +static void parse_VkClearRect(const char* s, Json::Value& obj, VkClearRect& o); +static void parse_VkComponentMapping(const char* s, Json::Value& obj, VkComponentMapping& o); +static void parse_VkPhysicalDeviceProperties(const char* s, Json::Value& obj, VkPhysicalDeviceProperties& o); +static void parse_VkExtensionProperties(const char* s, Json::Value& obj, VkExtensionProperties& o); +static void parse_VkLayerProperties(const char* s, Json::Value& obj, VkLayerProperties& o); +static void parse_VkApplicationInfo(const char* s, Json::Value& obj, VkApplicationInfo& o); +static void parse_VkAllocationCallbacks(const char* s, Json::Value& obj, VkAllocationCallbacks& o); +static void parse_VkDeviceQueueCreateInfo(const char* s, Json::Value& obj, VkDeviceQueueCreateInfo& o); +static void parse_VkDeviceCreateInfo(const char* s, Json::Value& obj, VkDeviceCreateInfo& o); +static void parse_VkInstanceCreateInfo(const char* s, Json::Value& obj, VkInstanceCreateInfo& o); +static void parse_VkQueueFamilyProperties(const char* s, Json::Value& obj, VkQueueFamilyProperties& o); +static void parse_VkPhysicalDeviceMemoryProperties(const char* s, Json::Value& obj, VkPhysicalDeviceMemoryProperties& o); +static void parse_VkMemoryAllocateInfo(const char* s, Json::Value& obj, VkMemoryAllocateInfo& o); +static void parse_VkMemoryRequirements(const char* s, Json::Value& obj, VkMemoryRequirements& o); +static void parse_VkMemoryType(const char* s, Json::Value& obj, VkMemoryType& o); +static void parse_VkMemoryHeap(const char* s, Json::Value& obj, VkMemoryHeap& o); +static void parse_VkMappedMemoryRange(const char* s, Json::Value& obj, VkMappedMemoryRange& o); +static void parse_VkFormatProperties(const char* s, Json::Value& obj, VkFormatProperties& o); +static void parse_VkImageFormatProperties(const char* s, Json::Value& obj, VkImageFormatProperties& o); +static void parse_VkDescriptorBufferInfo(const char* s, Json::Value& obj, VkDescriptorBufferInfo& o); +static void parse_VkDescriptorImageInfo(const char* s, Json::Value& obj, VkDescriptorImageInfo& o); +static void parse_VkWriteDescriptorSet(const char* s, Json::Value& obj, VkWriteDescriptorSet& o); +static void parse_VkCopyDescriptorSet(const char* s, Json::Value& obj, VkCopyDescriptorSet& o); +static void parse_VkBufferCreateInfo(const char* s, Json::Value& obj, VkBufferCreateInfo& o); +static void parse_VkBufferViewCreateInfo(const char* s, Json::Value& obj, VkBufferViewCreateInfo& o); +static void parse_VkImageSubresource(const char* s, Json::Value& obj, VkImageSubresource& o); +static void parse_VkImageSubresourceLayers(const char* s, Json::Value& obj, VkImageSubresourceLayers& o); +static void parse_VkImageSubresourceRange(const char* s, Json::Value& obj, VkImageSubresourceRange& o); +static void parse_VkMemoryBarrier(const char* s, Json::Value& obj, VkMemoryBarrier& o); +static void parse_VkBufferMemoryBarrier(const char* s, Json::Value& obj, VkBufferMemoryBarrier& o); +static void parse_VkImageMemoryBarrier(const char* s, Json::Value& obj, VkImageMemoryBarrier& o); +static void parse_VkImageCreateInfo(const char* s, Json::Value& obj, VkImageCreateInfo& o); +static void parse_VkSubresourceLayout(const char* s, Json::Value& obj, VkSubresourceLayout& o); +static void parse_VkImageViewCreateInfo(const char* s, Json::Value& obj, VkImageViewCreateInfo& o); +static void parse_VkBufferCopy(const char* s, Json::Value& obj, VkBufferCopy& o); +static void parse_VkImageCopy(const char* s, Json::Value& obj, VkImageCopy& o); +static void parse_VkImageBlit(const char* s, Json::Value& obj, VkImageBlit& o); +static void parse_VkBufferImageCopy(const char* s, Json::Value& obj, VkBufferImageCopy& o); +static void parse_VkImageResolve(const char* s, Json::Value& obj, VkImageResolve& o); +static void parse_VkDescriptorSetLayoutBinding(const char* s, Json::Value& obj, VkDescriptorSetLayoutBinding& o); +static void parse_VkDescriptorSetLayoutCreateInfo(const char* s, Json::Value& obj, VkDescriptorSetLayoutCreateInfo& o); +static void parse_VkDescriptorPoolSize(const char* s, Json::Value& obj, VkDescriptorPoolSize& o); +static void parse_VkDescriptorPoolCreateInfo(const char* s, Json::Value& obj, VkDescriptorPoolCreateInfo& o); +static void parse_VkDescriptorSetAllocateInfo(const char* s, Json::Value& obj, VkDescriptorSetAllocateInfo& o); +static void parse_VkSpecializationMapEntry(const char* s, Json::Value& obj, VkSpecializationMapEntry& o); +static void parse_VkSpecializationInfo(const char* s, Json::Value& obj, VkSpecializationInfo& o); +static void parse_VkPipelineShaderStageCreateInfo(const char* s, Json::Value& obj, VkPipelineShaderStageCreateInfo& o); +static void parse_VkComputePipelineCreateInfo(const char* s, Json::Value& obj, VkComputePipelineCreateInfo& o); +static void parse_VkVertexInputBindingDescription(const char* s, Json::Value& obj, VkVertexInputBindingDescription& o); +static void parse_VkVertexInputAttributeDescription(const char* s, Json::Value& obj, VkVertexInputAttributeDescription& o); +static void parse_VkPipelineVertexInputStateCreateInfo(const char* s, Json::Value& obj, VkPipelineVertexInputStateCreateInfo& o); +static void parse_VkPipelineInputAssemblyStateCreateInfo(const char* s, Json::Value& obj, VkPipelineInputAssemblyStateCreateInfo& o); +static void parse_VkPipelineTessellationStateCreateInfo(const char* s, Json::Value& obj, VkPipelineTessellationStateCreateInfo& o); +static void parse_VkPipelineViewportStateCreateInfo(const char* s, Json::Value& obj, VkPipelineViewportStateCreateInfo& o); +static void parse_VkPipelineRasterizationStateCreateInfo(const char* s, Json::Value& obj, VkPipelineRasterizationStateCreateInfo& o); +static void parse_VkPipelineMultisampleStateCreateInfo(const char* s, Json::Value& obj, VkPipelineMultisampleStateCreateInfo& o); +static void parse_VkPipelineColorBlendAttachmentState(const char* s, Json::Value& obj, VkPipelineColorBlendAttachmentState& o); +static void parse_VkPipelineColorBlendStateCreateInfo(const char* s, Json::Value& obj, VkPipelineColorBlendStateCreateInfo& o); +static void parse_VkPipelineDynamicStateCreateInfo(const char* s, Json::Value& obj, VkPipelineDynamicStateCreateInfo& o); +static void parse_VkStencilOpState(const char* s, Json::Value& obj, VkStencilOpState& o); +static void parse_VkPipelineDepthStencilStateCreateInfo(const char* s, Json::Value& obj, VkPipelineDepthStencilStateCreateInfo& o); +static void parse_VkGraphicsPipelineCreateInfo(const char* s, Json::Value& obj, VkGraphicsPipelineCreateInfo& o); +static void parse_VkPipelineCacheCreateInfo(const char* s, Json::Value& obj, VkPipelineCacheCreateInfo& o); +static void parse_VkPipelineCacheHeaderVersionOne(const char* s, Json::Value& obj, VkPipelineCacheHeaderVersionOne& o); +#ifdef VKSC_VERSION_1_0 +static void parse_VkPipelineCacheStageValidationIndexEntry(const char* s, Json::Value& obj, VkPipelineCacheStageValidationIndexEntry& o); +static void parse_VkPipelineCacheSafetyCriticalIndexEntry(const char* s, Json::Value& obj, VkPipelineCacheSafetyCriticalIndexEntry& o); +static void parse_VkPipelineCacheHeaderVersionSafetyCriticalOne(const char* s, Json::Value& obj, VkPipelineCacheHeaderVersionSafetyCriticalOne& o); +#endif +static void parse_VkPushConstantRange(const char* s, Json::Value& obj, VkPushConstantRange& o); +static void parse_VkPipelineLayoutCreateInfo(const char* s, Json::Value& obj, VkPipelineLayoutCreateInfo& o); +static void parse_VkSamplerCreateInfo(const char* s, Json::Value& obj, VkSamplerCreateInfo& o); +static void parse_VkCommandPoolCreateInfo(const char* s, Json::Value& obj, VkCommandPoolCreateInfo& o); +static void parse_VkCommandBufferAllocateInfo(const char* s, Json::Value& obj, VkCommandBufferAllocateInfo& o); +static void parse_VkCommandBufferInheritanceInfo(const char* s, Json::Value& obj, VkCommandBufferInheritanceInfo& o); +static void parse_VkCommandBufferBeginInfo(const char* s, Json::Value& obj, VkCommandBufferBeginInfo& o); +static void parse_VkRenderPassBeginInfo(const char* s, Json::Value& obj, VkRenderPassBeginInfo& o); +static void parse_VkClearDepthStencilValue(const char* s, Json::Value& obj, VkClearDepthStencilValue& o); +static void parse_VkClearAttachment(const char* s, Json::Value& obj, VkClearAttachment& o); +static void parse_VkAttachmentDescription(const char* s, Json::Value& obj, VkAttachmentDescription& o); +static void parse_VkAttachmentReference(const char* s, Json::Value& obj, VkAttachmentReference& o); +static void parse_VkSubpassDescription(const char* s, Json::Value& obj, VkSubpassDescription& o); +static void parse_VkSubpassDependency(const char* s, Json::Value& obj, VkSubpassDependency& o); +static void parse_VkRenderPassCreateInfo(const char* s, Json::Value& obj, VkRenderPassCreateInfo& o); +static void parse_VkEventCreateInfo(const char* s, Json::Value& obj, VkEventCreateInfo& o); +static void parse_VkFenceCreateInfo(const char* s, Json::Value& obj, VkFenceCreateInfo& o); +static void parse_VkPhysicalDeviceFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceFeatures& o); +static void parse_VkPhysicalDeviceSparseProperties(const char* s, Json::Value& obj, VkPhysicalDeviceSparseProperties& o); +static void parse_VkPhysicalDeviceLimits(const char* s, Json::Value& obj, VkPhysicalDeviceLimits& o); +static void parse_VkSemaphoreCreateInfo(const char* s, Json::Value& obj, VkSemaphoreCreateInfo& o); +static void parse_VkQueryPoolCreateInfo(const char* s, Json::Value& obj, VkQueryPoolCreateInfo& o); +static void parse_VkFramebufferCreateInfo(const char* s, Json::Value& obj, VkFramebufferCreateInfo& o); +static void parse_VkDrawIndirectCommand(const char* s, Json::Value& obj, VkDrawIndirectCommand& o); +static void parse_VkDrawIndexedIndirectCommand(const char* s, Json::Value& obj, VkDrawIndexedIndirectCommand& o); +static void parse_VkDispatchIndirectCommand(const char* s, Json::Value& obj, VkDispatchIndirectCommand& o); +static void parse_VkSubmitInfo(const char* s, Json::Value& obj, VkSubmitInfo& o); +#ifdef VK_KHR_display +static void parse_VkDisplayPropertiesKHR(const char* s, Json::Value& obj, VkDisplayPropertiesKHR& o); +static void parse_VkDisplayPlanePropertiesKHR(const char* s, Json::Value& obj, VkDisplayPlanePropertiesKHR& o); +static void parse_VkDisplayModeParametersKHR(const char* s, Json::Value& obj, VkDisplayModeParametersKHR& o); +static void parse_VkDisplayModePropertiesKHR(const char* s, Json::Value& obj, VkDisplayModePropertiesKHR& o); +static void parse_VkDisplayModeCreateInfoKHR(const char* s, Json::Value& obj, VkDisplayModeCreateInfoKHR& o); +static void parse_VkDisplayPlaneCapabilitiesKHR(const char* s, Json::Value& obj, VkDisplayPlaneCapabilitiesKHR& o); +static void parse_VkDisplaySurfaceCreateInfoKHR(const char* s, Json::Value& obj, VkDisplaySurfaceCreateInfoKHR& o); +#endif +#ifdef VK_KHR_display_swapchain +static void parse_VkDisplayPresentInfoKHR(const char* s, Json::Value& obj, VkDisplayPresentInfoKHR& o); +#endif +#ifdef VK_KHR_surface +static void parse_VkSurfaceCapabilitiesKHR(const char* s, Json::Value& obj, VkSurfaceCapabilitiesKHR& o); +static void parse_VkSurfaceFormatKHR(const char* s, Json::Value& obj, VkSurfaceFormatKHR& o); +#endif +#ifdef VK_KHR_swapchain +static void parse_VkSwapchainCreateInfoKHR(const char* s, Json::Value& obj, VkSwapchainCreateInfoKHR& o); +static void parse_VkPresentInfoKHR(const char* s, Json::Value& obj, VkPresentInfoKHR& o); +#endif +#ifdef VK_EXT_validation_features +static void parse_VkValidationFeaturesEXT(const char* s, Json::Value& obj, VkValidationFeaturesEXT& o); +#endif +#ifdef VK_EXT_application_parameters +static void parse_VkApplicationParametersEXT(const char* s, Json::Value& obj, VkApplicationParametersEXT& o); +#endif +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceFeatures2(const char* s, Json::Value& obj, VkPhysicalDeviceFeatures2& o); +static void parse_VkPhysicalDeviceProperties2(const char* s, Json::Value& obj, VkPhysicalDeviceProperties2& o); +static void parse_VkFormatProperties2(const char* s, Json::Value& obj, VkFormatProperties2& o); +static void parse_VkImageFormatProperties2(const char* s, Json::Value& obj, VkImageFormatProperties2& o); +static void parse_VkPhysicalDeviceImageFormatInfo2(const char* s, Json::Value& obj, VkPhysicalDeviceImageFormatInfo2& o); +static void parse_VkQueueFamilyProperties2(const char* s, Json::Value& obj, VkQueueFamilyProperties2& o); +static void parse_VkPhysicalDeviceMemoryProperties2(const char* s, Json::Value& obj, VkPhysicalDeviceMemoryProperties2& o); +#endif +#ifdef VK_VERSION_1_2 +static void parse_VkConformanceVersion(const char* s, Json::Value& obj, VkConformanceVersion& o); +static void parse_VkPhysicalDeviceDriverProperties(const char* s, Json::Value& obj, VkPhysicalDeviceDriverProperties& o); +#endif +#ifdef VK_KHR_incremental_present +static void parse_VkPresentRegionsKHR(const char* s, Json::Value& obj, VkPresentRegionsKHR& o); +static void parse_VkPresentRegionKHR(const char* s, Json::Value& obj, VkPresentRegionKHR& o); +static void parse_VkRectLayerKHR(const char* s, Json::Value& obj, VkRectLayerKHR& o); +#endif +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceVariablePointersFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceVariablePointersFeatures& o); +static void parse_VkPhysicalDeviceVariablePointerFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceVariablePointerFeatures& o); +static void parse_VkExternalMemoryProperties(const char* s, Json::Value& obj, VkExternalMemoryProperties& o); +static void parse_VkPhysicalDeviceExternalImageFormatInfo(const char* s, Json::Value& obj, VkPhysicalDeviceExternalImageFormatInfo& o); +static void parse_VkExternalImageFormatProperties(const char* s, Json::Value& obj, VkExternalImageFormatProperties& o); +static void parse_VkPhysicalDeviceExternalBufferInfo(const char* s, Json::Value& obj, VkPhysicalDeviceExternalBufferInfo& o); +static void parse_VkExternalBufferProperties(const char* s, Json::Value& obj, VkExternalBufferProperties& o); +static void parse_VkPhysicalDeviceIDProperties(const char* s, Json::Value& obj, VkPhysicalDeviceIDProperties& o); +static void parse_VkExternalMemoryImageCreateInfo(const char* s, Json::Value& obj, VkExternalMemoryImageCreateInfo& o); +static void parse_VkExternalMemoryBufferCreateInfo(const char* s, Json::Value& obj, VkExternalMemoryBufferCreateInfo& o); +static void parse_VkExportMemoryAllocateInfo(const char* s, Json::Value& obj, VkExportMemoryAllocateInfo& o); +#endif +#ifdef VK_KHR_external_memory_fd +static void parse_VkImportMemoryFdInfoKHR(const char* s, Json::Value& obj, VkImportMemoryFdInfoKHR& o); +static void parse_VkMemoryFdPropertiesKHR(const char* s, Json::Value& obj, VkMemoryFdPropertiesKHR& o); +static void parse_VkMemoryGetFdInfoKHR(const char* s, Json::Value& obj, VkMemoryGetFdInfoKHR& o); +#endif +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceExternalSemaphoreInfo(const char* s, Json::Value& obj, VkPhysicalDeviceExternalSemaphoreInfo& o); +static void parse_VkExternalSemaphoreProperties(const char* s, Json::Value& obj, VkExternalSemaphoreProperties& o); +static void parse_VkExportSemaphoreCreateInfo(const char* s, Json::Value& obj, VkExportSemaphoreCreateInfo& o); +#endif +#ifdef VK_KHR_external_semaphore_fd +static void parse_VkImportSemaphoreFdInfoKHR(const char* s, Json::Value& obj, VkImportSemaphoreFdInfoKHR& o); +static void parse_VkSemaphoreGetFdInfoKHR(const char* s, Json::Value& obj, VkSemaphoreGetFdInfoKHR& o); +#endif +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceExternalFenceInfo(const char* s, Json::Value& obj, VkPhysicalDeviceExternalFenceInfo& o); +static void parse_VkExternalFenceProperties(const char* s, Json::Value& obj, VkExternalFenceProperties& o); +static void parse_VkExportFenceCreateInfo(const char* s, Json::Value& obj, VkExportFenceCreateInfo& o); +#endif +#ifdef VK_KHR_external_fence_fd +static void parse_VkImportFenceFdInfoKHR(const char* s, Json::Value& obj, VkImportFenceFdInfoKHR& o); +static void parse_VkFenceGetFdInfoKHR(const char* s, Json::Value& obj, VkFenceGetFdInfoKHR& o); +#endif +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceMultiviewFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceMultiviewFeatures& o); +static void parse_VkPhysicalDeviceMultiviewProperties(const char* s, Json::Value& obj, VkPhysicalDeviceMultiviewProperties& o); +static void parse_VkRenderPassMultiviewCreateInfo(const char* s, Json::Value& obj, VkRenderPassMultiviewCreateInfo& o); +#endif +#ifdef VK_EXT_display_surface_counter +static void parse_VkSurfaceCapabilities2EXT(const char* s, Json::Value& obj, VkSurfaceCapabilities2EXT& o); +#endif +#ifdef VK_EXT_display_control +static void parse_VkDisplayPowerInfoEXT(const char* s, Json::Value& obj, VkDisplayPowerInfoEXT& o); +static void parse_VkDeviceEventInfoEXT(const char* s, Json::Value& obj, VkDeviceEventInfoEXT& o); +static void parse_VkDisplayEventInfoEXT(const char* s, Json::Value& obj, VkDisplayEventInfoEXT& o); +static void parse_VkSwapchainCounterCreateInfoEXT(const char* s, Json::Value& obj, VkSwapchainCounterCreateInfoEXT& o); +#endif +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceGroupProperties(const char* s, Json::Value& obj, VkPhysicalDeviceGroupProperties& o); +static void parse_VkMemoryAllocateFlagsInfo(const char* s, Json::Value& obj, VkMemoryAllocateFlagsInfo& o); +static void parse_VkBindBufferMemoryInfo(const char* s, Json::Value& obj, VkBindBufferMemoryInfo& o); +static void parse_VkBindBufferMemoryDeviceGroupInfo(const char* s, Json::Value& obj, VkBindBufferMemoryDeviceGroupInfo& o); +static void parse_VkBindImageMemoryInfo(const char* s, Json::Value& obj, VkBindImageMemoryInfo& o); +static void parse_VkBindImageMemoryDeviceGroupInfo(const char* s, Json::Value& obj, VkBindImageMemoryDeviceGroupInfo& o); +static void parse_VkDeviceGroupRenderPassBeginInfo(const char* s, Json::Value& obj, VkDeviceGroupRenderPassBeginInfo& o); +static void parse_VkDeviceGroupCommandBufferBeginInfo(const char* s, Json::Value& obj, VkDeviceGroupCommandBufferBeginInfo& o); +static void parse_VkDeviceGroupSubmitInfo(const char* s, Json::Value& obj, VkDeviceGroupSubmitInfo& o); +#endif +#ifdef VK_KHR_swapchain +static void parse_VkDeviceGroupPresentCapabilitiesKHR(const char* s, Json::Value& obj, VkDeviceGroupPresentCapabilitiesKHR& o); +static void parse_VkImageSwapchainCreateInfoKHR(const char* s, Json::Value& obj, VkImageSwapchainCreateInfoKHR& o); +static void parse_VkBindImageMemorySwapchainInfoKHR(const char* s, Json::Value& obj, VkBindImageMemorySwapchainInfoKHR& o); +static void parse_VkAcquireNextImageInfoKHR(const char* s, Json::Value& obj, VkAcquireNextImageInfoKHR& o); +static void parse_VkDeviceGroupPresentInfoKHR(const char* s, Json::Value& obj, VkDeviceGroupPresentInfoKHR& o); +#endif +#ifdef VK_VERSION_1_1 +static void parse_VkDeviceGroupDeviceCreateInfo(const char* s, Json::Value& obj, VkDeviceGroupDeviceCreateInfo& o); +#endif +#ifdef VK_KHR_swapchain +static void parse_VkDeviceGroupSwapchainCreateInfoKHR(const char* s, Json::Value& obj, VkDeviceGroupSwapchainCreateInfoKHR& o); +#endif +#ifdef VK_EXT_hdr_metadata +static void parse_VkXYColorEXT(const char* s, Json::Value& obj, VkXYColorEXT& o); +static void parse_VkHdrMetadataEXT(const char* s, Json::Value& obj, VkHdrMetadataEXT& o); +#endif +#ifdef VK_EXT_discard_rectangles +static void parse_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceDiscardRectanglePropertiesEXT& o); +static void parse_VkPipelineDiscardRectangleStateCreateInfoEXT(const char* s, Json::Value& obj, VkPipelineDiscardRectangleStateCreateInfoEXT& o); +#endif +#ifdef VK_VERSION_1_1 +static void parse_VkInputAttachmentAspectReference(const char* s, Json::Value& obj, VkInputAttachmentAspectReference& o); +static void parse_VkRenderPassInputAttachmentAspectCreateInfo(const char* s, Json::Value& obj, VkRenderPassInputAttachmentAspectCreateInfo& o); +#endif +#ifdef VK_KHR_get_surface_capabilities2 +static void parse_VkPhysicalDeviceSurfaceInfo2KHR(const char* s, Json::Value& obj, VkPhysicalDeviceSurfaceInfo2KHR& o); +static void parse_VkSurfaceCapabilities2KHR(const char* s, Json::Value& obj, VkSurfaceCapabilities2KHR& o); +static void parse_VkSurfaceFormat2KHR(const char* s, Json::Value& obj, VkSurfaceFormat2KHR& o); +#endif +#ifdef VK_KHR_get_display_properties2 +static void parse_VkDisplayProperties2KHR(const char* s, Json::Value& obj, VkDisplayProperties2KHR& o); +static void parse_VkDisplayPlaneProperties2KHR(const char* s, Json::Value& obj, VkDisplayPlaneProperties2KHR& o); +static void parse_VkDisplayModeProperties2KHR(const char* s, Json::Value& obj, VkDisplayModeProperties2KHR& o); +static void parse_VkDisplayPlaneInfo2KHR(const char* s, Json::Value& obj, VkDisplayPlaneInfo2KHR& o); +static void parse_VkDisplayPlaneCapabilities2KHR(const char* s, Json::Value& obj, VkDisplayPlaneCapabilities2KHR& o); +#endif +#ifdef VK_KHR_shared_presentable_image +static void parse_VkSharedPresentSurfaceCapabilitiesKHR(const char* s, Json::Value& obj, VkSharedPresentSurfaceCapabilitiesKHR& o); +#endif +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDevice16BitStorageFeatures(const char* s, Json::Value& obj, VkPhysicalDevice16BitStorageFeatures& o); +static void parse_VkPhysicalDeviceSubgroupProperties(const char* s, Json::Value& obj, VkPhysicalDeviceSubgroupProperties& o); +#endif +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& o); +#endif +#ifdef VK_VERSION_1_1 +static void parse_VkBufferMemoryRequirementsInfo2(const char* s, Json::Value& obj, VkBufferMemoryRequirementsInfo2& o); +static void parse_VkImageMemoryRequirementsInfo2(const char* s, Json::Value& obj, VkImageMemoryRequirementsInfo2& o); +static void parse_VkMemoryRequirements2(const char* s, Json::Value& obj, VkMemoryRequirements2& o); +static void parse_VkPhysicalDevicePointClippingProperties(const char* s, Json::Value& obj, VkPhysicalDevicePointClippingProperties& o); +static void parse_VkMemoryDedicatedRequirements(const char* s, Json::Value& obj, VkMemoryDedicatedRequirements& o); +static void parse_VkMemoryDedicatedAllocateInfo(const char* s, Json::Value& obj, VkMemoryDedicatedAllocateInfo& o); +static void parse_VkImageViewUsageCreateInfo(const char* s, Json::Value& obj, VkImageViewUsageCreateInfo& o); +static void parse_VkPipelineTessellationDomainOriginStateCreateInfo(const char* s, Json::Value& obj, VkPipelineTessellationDomainOriginStateCreateInfo& o); +static void parse_VkSamplerYcbcrConversionInfo(const char* s, Json::Value& obj, VkSamplerYcbcrConversionInfo& o); +static void parse_VkSamplerYcbcrConversionCreateInfo(const char* s, Json::Value& obj, VkSamplerYcbcrConversionCreateInfo& o); +static void parse_VkBindImagePlaneMemoryInfo(const char* s, Json::Value& obj, VkBindImagePlaneMemoryInfo& o); +static void parse_VkImagePlaneMemoryRequirementsInfo(const char* s, Json::Value& obj, VkImagePlaneMemoryRequirementsInfo& o); +static void parse_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceSamplerYcbcrConversionFeatures& o); +static void parse_VkSamplerYcbcrConversionImageFormatProperties(const char* s, Json::Value& obj, VkSamplerYcbcrConversionImageFormatProperties& o); +static void parse_VkProtectedSubmitInfo(const char* s, Json::Value& obj, VkProtectedSubmitInfo& o); +static void parse_VkPhysicalDeviceProtectedMemoryFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceProtectedMemoryFeatures& o); +static void parse_VkPhysicalDeviceProtectedMemoryProperties(const char* s, Json::Value& obj, VkPhysicalDeviceProtectedMemoryProperties& o); +static void parse_VkDeviceQueueInfo2(const char* s, Json::Value& obj, VkDeviceQueueInfo2& o); +#endif +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceSamplerFilterMinmaxProperties(const char* s, Json::Value& obj, VkPhysicalDeviceSamplerFilterMinmaxProperties& o); +#endif +#ifdef VK_EXT_sample_locations +static void parse_VkSampleLocationEXT(const char* s, Json::Value& obj, VkSampleLocationEXT& o); +static void parse_VkSampleLocationsInfoEXT(const char* s, Json::Value& obj, VkSampleLocationsInfoEXT& o); +static void parse_VkAttachmentSampleLocationsEXT(const char* s, Json::Value& obj, VkAttachmentSampleLocationsEXT& o); +static void parse_VkSubpassSampleLocationsEXT(const char* s, Json::Value& obj, VkSubpassSampleLocationsEXT& o); +static void parse_VkRenderPassSampleLocationsBeginInfoEXT(const char* s, Json::Value& obj, VkRenderPassSampleLocationsBeginInfoEXT& o); +static void parse_VkPipelineSampleLocationsStateCreateInfoEXT(const char* s, Json::Value& obj, VkPipelineSampleLocationsStateCreateInfoEXT& o); +static void parse_VkPhysicalDeviceSampleLocationsPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceSampleLocationsPropertiesEXT& o); +static void parse_VkMultisamplePropertiesEXT(const char* s, Json::Value& obj, VkMultisamplePropertiesEXT& o); +#endif +#ifdef VK_VERSION_1_2 +static void parse_VkSamplerReductionModeCreateInfo(const char* s, Json::Value& obj, VkSamplerReductionModeCreateInfo& o); +#endif +#ifdef VK_EXT_blend_operation_advanced +static void parse_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& o); +static void parse_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& o); +static void parse_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const char* s, Json::Value& obj, VkPipelineColorBlendAdvancedStateCreateInfoEXT& o); +#endif +#ifdef VK_VERSION_1_2 +static void parse_VkImageFormatListCreateInfo(const char* s, Json::Value& obj, VkImageFormatListCreateInfo& o); +#endif +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceMaintenance3Properties(const char* s, Json::Value& obj, VkPhysicalDeviceMaintenance3Properties& o); +static void parse_VkDescriptorSetLayoutSupport(const char* s, Json::Value& obj, VkDescriptorSetLayoutSupport& o); +static void parse_VkPhysicalDeviceShaderDrawParametersFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceShaderDrawParametersFeatures& o); +static void parse_VkPhysicalDeviceShaderDrawParameterFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceShaderDrawParameterFeatures& o); +#endif +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceShaderFloat16Int8Features(const char* s, Json::Value& obj, VkPhysicalDeviceShaderFloat16Int8Features& o); +static void parse_VkPhysicalDeviceFloatControlsProperties(const char* s, Json::Value& obj, VkPhysicalDeviceFloatControlsProperties& o); +static void parse_VkPhysicalDeviceHostQueryResetFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceHostQueryResetFeatures& o); +#endif +#ifdef VK_EXT_global_priority +static void parse_VkDeviceQueueGlobalPriorityCreateInfoEXT(const char* s, Json::Value& obj, VkDeviceQueueGlobalPriorityCreateInfoEXT& o); +#endif +#ifdef VK_EXT_debug_utils +static void parse_VkDebugUtilsObjectNameInfoEXT(const char* s, Json::Value& obj, VkDebugUtilsObjectNameInfoEXT& o); +static void parse_VkDebugUtilsObjectTagInfoEXT(const char* s, Json::Value& obj, VkDebugUtilsObjectTagInfoEXT& o); +static void parse_VkDebugUtilsLabelEXT(const char* s, Json::Value& obj, VkDebugUtilsLabelEXT& o); +static void parse_VkDebugUtilsMessengerCreateInfoEXT(const char* s, Json::Value& obj, VkDebugUtilsMessengerCreateInfoEXT& o); +static void parse_VkDebugUtilsMessengerCallbackDataEXT(const char* s, Json::Value& obj, VkDebugUtilsMessengerCallbackDataEXT& o); +#endif +#ifdef VK_EXT_external_memory_host +static void parse_VkImportMemoryHostPointerInfoEXT(const char* s, Json::Value& obj, VkImportMemoryHostPointerInfoEXT& o); +static void parse_VkMemoryHostPointerPropertiesEXT(const char* s, Json::Value& obj, VkMemoryHostPointerPropertiesEXT& o); +static void parse_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceExternalMemoryHostPropertiesEXT& o); +#endif +#ifdef VK_EXT_conservative_rasterization +static void parse_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceConservativeRasterizationPropertiesEXT& o); +#endif +#ifdef VK_EXT_calibrated_timestamps +static void parse_VkCalibratedTimestampInfoEXT(const char* s, Json::Value& obj, VkCalibratedTimestampInfoEXT& o); +#endif +#ifdef VK_EXT_conservative_rasterization +static void parse_VkPipelineRasterizationConservativeStateCreateInfoEXT(const char* s, Json::Value& obj, VkPipelineRasterizationConservativeStateCreateInfoEXT& o); +#endif +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceDescriptorIndexingFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceDescriptorIndexingFeatures& o); +static void parse_VkPhysicalDeviceDescriptorIndexingProperties(const char* s, Json::Value& obj, VkPhysicalDeviceDescriptorIndexingProperties& o); +static void parse_VkDescriptorSetLayoutBindingFlagsCreateInfo(const char* s, Json::Value& obj, VkDescriptorSetLayoutBindingFlagsCreateInfo& o); +static void parse_VkDescriptorSetVariableDescriptorCountAllocateInfo(const char* s, Json::Value& obj, VkDescriptorSetVariableDescriptorCountAllocateInfo& o); +static void parse_VkDescriptorSetVariableDescriptorCountLayoutSupport(const char* s, Json::Value& obj, VkDescriptorSetVariableDescriptorCountLayoutSupport& o); +static void parse_VkAttachmentDescription2(const char* s, Json::Value& obj, VkAttachmentDescription2& o); +static void parse_VkAttachmentReference2(const char* s, Json::Value& obj, VkAttachmentReference2& o); +static void parse_VkSubpassDescription2(const char* s, Json::Value& obj, VkSubpassDescription2& o); +static void parse_VkSubpassDependency2(const char* s, Json::Value& obj, VkSubpassDependency2& o); +static void parse_VkRenderPassCreateInfo2(const char* s, Json::Value& obj, VkRenderPassCreateInfo2& o); +static void parse_VkSubpassBeginInfo(const char* s, Json::Value& obj, VkSubpassBeginInfo& o); +static void parse_VkSubpassEndInfo(const char* s, Json::Value& obj, VkSubpassEndInfo& o); +static void parse_VkPhysicalDeviceTimelineSemaphoreFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceTimelineSemaphoreFeatures& o); +static void parse_VkPhysicalDeviceTimelineSemaphoreProperties(const char* s, Json::Value& obj, VkPhysicalDeviceTimelineSemaphoreProperties& o); +static void parse_VkSemaphoreTypeCreateInfo(const char* s, Json::Value& obj, VkSemaphoreTypeCreateInfo& o); +static void parse_VkTimelineSemaphoreSubmitInfo(const char* s, Json::Value& obj, VkTimelineSemaphoreSubmitInfo& o); +static void parse_VkSemaphoreWaitInfo(const char* s, Json::Value& obj, VkSemaphoreWaitInfo& o); +static void parse_VkSemaphoreSignalInfo(const char* s, Json::Value& obj, VkSemaphoreSignalInfo& o); +#endif +#ifdef VK_EXT_vertex_attribute_divisor +static void parse_VkVertexInputBindingDivisorDescriptionEXT(const char* s, Json::Value& obj, VkVertexInputBindingDivisorDescriptionEXT& o); +static void parse_VkPipelineVertexInputDivisorStateCreateInfoEXT(const char* s, Json::Value& obj, VkPipelineVertexInputDivisorStateCreateInfoEXT& o); +static void parse_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& o); +#endif +#ifdef VK_EXT_pci_bus_info +static void parse_VkPhysicalDevicePCIBusInfoPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDevicePCIBusInfoPropertiesEXT& o); +#endif +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDevice8BitStorageFeatures(const char* s, Json::Value& obj, VkPhysicalDevice8BitStorageFeatures& o); +static void parse_VkPhysicalDeviceVulkanMemoryModelFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceVulkanMemoryModelFeatures& o); +static void parse_VkPhysicalDeviceShaderAtomicInt64Features(const char* s, Json::Value& obj, VkPhysicalDeviceShaderAtomicInt64Features& o); +#endif +#ifdef VK_EXT_shader_atomic_float +static void parse_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& o); +#endif +#ifdef VK_EXT_vertex_attribute_divisor +static void parse_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& o); +#endif +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceDepthStencilResolveProperties(const char* s, Json::Value& obj, VkPhysicalDeviceDepthStencilResolveProperties& o); +static void parse_VkSubpassDescriptionDepthStencilResolve(const char* s, Json::Value& obj, VkSubpassDescriptionDepthStencilResolve& o); +#endif +#ifdef VK_EXT_astc_decode_mode +static void parse_VkImageViewASTCDecodeModeEXT(const char* s, Json::Value& obj, VkImageViewASTCDecodeModeEXT& o); +static void parse_VkPhysicalDeviceASTCDecodeFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceASTCDecodeFeaturesEXT& o); +#endif +#ifdef VK_EXT_image_drm_format_modifier +static void parse_VkDrmFormatModifierPropertiesListEXT(const char* s, Json::Value& obj, VkDrmFormatModifierPropertiesListEXT& o); +static void parse_VkDrmFormatModifierPropertiesEXT(const char* s, Json::Value& obj, VkDrmFormatModifierPropertiesEXT& o); +static void parse_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const char* s, Json::Value& obj, VkPhysicalDeviceImageDrmFormatModifierInfoEXT& o); +static void parse_VkImageDrmFormatModifierListCreateInfoEXT(const char* s, Json::Value& obj, VkImageDrmFormatModifierListCreateInfoEXT& o); +static void parse_VkImageDrmFormatModifierExplicitCreateInfoEXT(const char* s, Json::Value& obj, VkImageDrmFormatModifierExplicitCreateInfoEXT& o); +static void parse_VkImageDrmFormatModifierPropertiesEXT(const char* s, Json::Value& obj, VkImageDrmFormatModifierPropertiesEXT& o); +#endif +#ifdef VK_VERSION_1_2 +static void parse_VkImageStencilUsageCreateInfo(const char* s, Json::Value& obj, VkImageStencilUsageCreateInfo& o); +static void parse_VkPhysicalDeviceScalarBlockLayoutFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceScalarBlockLayoutFeatures& o); +static void parse_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceUniformBufferStandardLayoutFeatures& o); +#endif +#ifdef VK_EXT_depth_clip_enable +static void parse_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceDepthClipEnableFeaturesEXT& o); +static void parse_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const char* s, Json::Value& obj, VkPipelineRasterizationDepthClipStateCreateInfoEXT& o); +#endif +#ifdef VK_EXT_memory_budget +static void parse_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceMemoryBudgetPropertiesEXT& o); +#endif +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceBufferDeviceAddressFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceBufferDeviceAddressFeatures& o); +static void parse_VkBufferDeviceAddressInfo(const char* s, Json::Value& obj, VkBufferDeviceAddressInfo& o); +static void parse_VkBufferOpaqueCaptureAddressCreateInfo(const char* s, Json::Value& obj, VkBufferOpaqueCaptureAddressCreateInfo& o); +#endif +#ifdef VK_EXT_filter_cubic +static void parse_VkPhysicalDeviceImageViewImageFormatInfoEXT(const char* s, Json::Value& obj, VkPhysicalDeviceImageViewImageFormatInfoEXT& o); +static void parse_VkFilterCubicImageViewImageFormatPropertiesEXT(const char* s, Json::Value& obj, VkFilterCubicImageViewImageFormatPropertiesEXT& o); +#endif +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceImagelessFramebufferFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceImagelessFramebufferFeatures& o); +static void parse_VkFramebufferAttachmentsCreateInfo(const char* s, Json::Value& obj, VkFramebufferAttachmentsCreateInfo& o); +static void parse_VkFramebufferAttachmentImageInfo(const char* s, Json::Value& obj, VkFramebufferAttachmentImageInfo& o); +static void parse_VkRenderPassAttachmentBeginInfo(const char* s, Json::Value& obj, VkRenderPassAttachmentBeginInfo& o); +#endif +#ifdef VK_EXT_texture_compression_astc_hdr +static void parse_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& o); +#endif +#ifdef VK_EXT_ycbcr_image_arrays +static void parse_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& o); +#endif +#ifdef VK_KHR_performance_query +static void parse_VkPhysicalDevicePerformanceQueryFeaturesKHR(const char* s, Json::Value& obj, VkPhysicalDevicePerformanceQueryFeaturesKHR& o); +static void parse_VkPhysicalDevicePerformanceQueryPropertiesKHR(const char* s, Json::Value& obj, VkPhysicalDevicePerformanceQueryPropertiesKHR& o); +static void parse_VkPerformanceCounterKHR(const char* s, Json::Value& obj, VkPerformanceCounterKHR& o); +static void parse_VkPerformanceCounterDescriptionKHR(const char* s, Json::Value& obj, VkPerformanceCounterDescriptionKHR& o); +static void parse_VkQueryPoolPerformanceCreateInfoKHR(const char* s, Json::Value& obj, VkQueryPoolPerformanceCreateInfoKHR& o); +static void parse_VkAcquireProfilingLockInfoKHR(const char* s, Json::Value& obj, VkAcquireProfilingLockInfoKHR& o); +static void parse_VkPerformanceQuerySubmitInfoKHR(const char* s, Json::Value& obj, VkPerformanceQuerySubmitInfoKHR& o); +static void parse_VkPerformanceQueryReservationInfoKHR(const char* s, Json::Value& obj, VkPerformanceQueryReservationInfoKHR& o); +#endif +#ifdef VK_EXT_headless_surface +static void parse_VkHeadlessSurfaceCreateInfoEXT(const char* s, Json::Value& obj, VkHeadlessSurfaceCreateInfoEXT& o); +#endif +#ifdef VK_KHR_shader_clock +static void parse_VkPhysicalDeviceShaderClockFeaturesKHR(const char* s, Json::Value& obj, VkPhysicalDeviceShaderClockFeaturesKHR& o); +#endif +#ifdef VK_EXT_index_type_uint8 +static void parse_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceIndexTypeUint8FeaturesEXT& o); +#endif +#ifdef VK_EXT_fragment_shader_interlock +static void parse_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& o); +#endif +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& o); +static void parse_VkAttachmentReferenceStencilLayout(const char* s, Json::Value& obj, VkAttachmentReferenceStencilLayout& o); +static void parse_VkAttachmentDescriptionStencilLayout(const char* s, Json::Value& obj, VkAttachmentDescriptionStencilLayout& o); +#endif +#ifdef VK_EXT_shader_demote_to_helper_invocation +static void parse_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& o); +#endif +#ifdef VK_EXT_texel_buffer_alignment +static void parse_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& o); +static void parse_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT& o); +#endif +#ifdef VK_EXT_subgroup_size_control +static void parse_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT& o); +static void parse_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceSubgroupSizeControlPropertiesEXT& o); +static void parse_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(const char* s, Json::Value& obj, VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& o); +#endif +#ifdef VK_VERSION_1_2 +static void parse_VkMemoryOpaqueCaptureAddressAllocateInfo(const char* s, Json::Value& obj, VkMemoryOpaqueCaptureAddressAllocateInfo& o); +static void parse_VkDeviceMemoryOpaqueCaptureAddressInfo(const char* s, Json::Value& obj, VkDeviceMemoryOpaqueCaptureAddressInfo& o); +#endif +#ifdef VK_EXT_line_rasterization +static void parse_VkPhysicalDeviceLineRasterizationFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceLineRasterizationFeaturesEXT& o); +static void parse_VkPhysicalDeviceLineRasterizationPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceLineRasterizationPropertiesEXT& o); +static void parse_VkPipelineRasterizationLineStateCreateInfoEXT(const char* s, Json::Value& obj, VkPipelineRasterizationLineStateCreateInfoEXT& o); +#endif +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceVulkan11Features(const char* s, Json::Value& obj, VkPhysicalDeviceVulkan11Features& o); +static void parse_VkPhysicalDeviceVulkan11Properties(const char* s, Json::Value& obj, VkPhysicalDeviceVulkan11Properties& o); +static void parse_VkPhysicalDeviceVulkan12Features(const char* s, Json::Value& obj, VkPhysicalDeviceVulkan12Features& o); +static void parse_VkPhysicalDeviceVulkan12Properties(const char* s, Json::Value& obj, VkPhysicalDeviceVulkan12Properties& o); +#endif +#ifdef VKSC_VERSION_1_0 +static void parse_VkFaultData(const char* s, Json::Value& obj, VkFaultData& o); +static void parse_VkFaultCallbackInfo(const char* s, Json::Value& obj, VkFaultCallbackInfo& o); +#endif +#ifdef VK_EXT_custom_border_color +static void parse_VkSamplerCustomBorderColorCreateInfoEXT(const char* s, Json::Value& obj, VkSamplerCustomBorderColorCreateInfoEXT& o); +static void parse_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceCustomBorderColorPropertiesEXT& o); +static void parse_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceCustomBorderColorFeaturesEXT& o); +#endif +#ifdef VK_KHR_object_refresh +static void parse_VkRefreshObjectKHR(const char* s, Json::Value& obj, VkRefreshObjectKHR& o); +static void parse_VkRefreshObjectListKHR(const char* s, Json::Value& obj, VkRefreshObjectListKHR& o); +#endif +#ifdef VK_EXT_extended_dynamic_state +static void parse_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& o); +#endif +#ifdef VK_EXT_extended_dynamic_state2 +static void parse_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& o); +#endif +#ifdef VKSC_VERSION_1_0 +static void parse_VkPipelineOfflineCreateInfo(const char* s, Json::Value& obj, VkPipelineOfflineCreateInfo& o); +#endif +#ifdef VK_EXT_robustness2 +static void parse_VkPhysicalDeviceRobustness2FeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceRobustness2FeaturesEXT& o); +static void parse_VkPhysicalDeviceRobustness2PropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceRobustness2PropertiesEXT& o); +#endif +#ifdef VK_EXT_image_robustness +static void parse_VkPhysicalDeviceImageRobustnessFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceImageRobustnessFeaturesEXT& o); +#endif +#ifdef VK_EXT_4444_formats +static void parse_VkPhysicalDevice4444FormatsFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDevice4444FormatsFeaturesEXT& o); +#endif +#ifdef VK_KHR_copy_commands2 +static void parse_VkBufferCopy2KHR(const char* s, Json::Value& obj, VkBufferCopy2KHR& o); +static void parse_VkImageCopy2KHR(const char* s, Json::Value& obj, VkImageCopy2KHR& o); +static void parse_VkImageBlit2KHR(const char* s, Json::Value& obj, VkImageBlit2KHR& o); +static void parse_VkBufferImageCopy2KHR(const char* s, Json::Value& obj, VkBufferImageCopy2KHR& o); +static void parse_VkImageResolve2KHR(const char* s, Json::Value& obj, VkImageResolve2KHR& o); +static void parse_VkCopyBufferInfo2KHR(const char* s, Json::Value& obj, VkCopyBufferInfo2KHR& o); +static void parse_VkCopyImageInfo2KHR(const char* s, Json::Value& obj, VkCopyImageInfo2KHR& o); +static void parse_VkBlitImageInfo2KHR(const char* s, Json::Value& obj, VkBlitImageInfo2KHR& o); +static void parse_VkCopyBufferToImageInfo2KHR(const char* s, Json::Value& obj, VkCopyBufferToImageInfo2KHR& o); +static void parse_VkCopyImageToBufferInfo2KHR(const char* s, Json::Value& obj, VkCopyImageToBufferInfo2KHR& o); +static void parse_VkResolveImageInfo2KHR(const char* s, Json::Value& obj, VkResolveImageInfo2KHR& o); +#endif +#ifdef VK_EXT_shader_image_atomic_int64 +static void parse_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& o); +#endif +#ifdef VK_KHR_fragment_shading_rate +static void parse_VkFragmentShadingRateAttachmentInfoKHR(const char* s, Json::Value& obj, VkFragmentShadingRateAttachmentInfoKHR& o); +static void parse_VkPipelineFragmentShadingRateStateCreateInfoKHR(const char* s, Json::Value& obj, VkPipelineFragmentShadingRateStateCreateInfoKHR& o); +static void parse_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const char* s, Json::Value& obj, VkPhysicalDeviceFragmentShadingRateFeaturesKHR& o); +static void parse_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const char* s, Json::Value& obj, VkPhysicalDeviceFragmentShadingRatePropertiesKHR& o); +static void parse_VkPhysicalDeviceFragmentShadingRateKHR(const char* s, Json::Value& obj, VkPhysicalDeviceFragmentShadingRateKHR& o); +#endif +#ifdef VK_KHR_shader_terminate_invocation +static void parse_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(const char* s, Json::Value& obj, VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR& o); +#endif +#ifdef VK_EXT_vertex_input_dynamic_state +static void parse_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& o); +static void parse_VkVertexInputBindingDescription2EXT(const char* s, Json::Value& obj, VkVertexInputBindingDescription2EXT& o); +static void parse_VkVertexInputAttributeDescription2EXT(const char* s, Json::Value& obj, VkVertexInputAttributeDescription2EXT& o); +#endif +#ifdef VK_EXT_color_write_enable +static void parse_VkPhysicalDeviceColorWriteEnableFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceColorWriteEnableFeaturesEXT& o); +static void parse_VkPipelineColorWriteCreateInfoEXT(const char* s, Json::Value& obj, VkPipelineColorWriteCreateInfoEXT& o); +#endif +#ifdef VK_KHR_synchronization2 +static void parse_VkMemoryBarrier2KHR(const char* s, Json::Value& obj, VkMemoryBarrier2KHR& o); +static void parse_VkImageMemoryBarrier2KHR(const char* s, Json::Value& obj, VkImageMemoryBarrier2KHR& o); +static void parse_VkBufferMemoryBarrier2KHR(const char* s, Json::Value& obj, VkBufferMemoryBarrier2KHR& o); +static void parse_VkDependencyInfoKHR(const char* s, Json::Value& obj, VkDependencyInfoKHR& o); +static void parse_VkSemaphoreSubmitInfoKHR(const char* s, Json::Value& obj, VkSemaphoreSubmitInfoKHR& o); +static void parse_VkCommandBufferSubmitInfoKHR(const char* s, Json::Value& obj, VkCommandBufferSubmitInfoKHR& o); +static void parse_VkSubmitInfo2KHR(const char* s, Json::Value& obj, VkSubmitInfo2KHR& o); +static void parse_VkQueueFamilyCheckpointProperties2NV(const char* s, Json::Value& obj, VkQueueFamilyCheckpointProperties2NV& o); +static void parse_VkCheckpointData2NV(const char* s, Json::Value& obj, VkCheckpointData2NV& o); +static void parse_VkPhysicalDeviceSynchronization2FeaturesKHR(const char* s, Json::Value& obj, VkPhysicalDeviceSynchronization2FeaturesKHR& o); +#endif +#ifdef VKSC_VERSION_1_0 +static void parse_VkPhysicalDeviceVulkanSC10Properties(const char* s, Json::Value& obj, VkPhysicalDeviceVulkanSC10Properties& o); +static void parse_VkPipelinePoolSize(const char* s, Json::Value& obj, VkPipelinePoolSize& o); +static void parse_VkDeviceObjectReservationCreateInfo(const char* s, Json::Value& obj, VkDeviceObjectReservationCreateInfo& o); +static void parse_VkCommandPoolMemoryReservationCreateInfo(const char* s, Json::Value& obj, VkCommandPoolMemoryReservationCreateInfo& o); +static void parse_VkCommandPoolMemoryConsumption(const char* s, Json::Value& obj, VkCommandPoolMemoryConsumption& o); +static void parse_VkPhysicalDeviceVulkanSC10Features(const char* s, Json::Value& obj, VkPhysicalDeviceVulkanSC10Features& o); +#endif +#ifdef VK_EXT_ycbcr_2plane_444_formats +static void parse_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& o); +#endif +#ifdef VK_EXT_image_drm_format_modifier +static void parse_VkDrmFormatModifierPropertiesList2EXT(const char* s, Json::Value& obj, VkDrmFormatModifierPropertiesList2EXT& o); +static void parse_VkDrmFormatModifierProperties2EXT(const char* s, Json::Value& obj, VkDrmFormatModifierProperties2EXT& o); +#endif +/*************************************** End prototypes ***********************************/ + + +static +void* parsePNextChain(Json::Value& obj) { + VkBaseInStructure o; + Json::Value& pNextObj = obj["pNext"]; + if (pNextObj.empty() || (pNextObj.isString() && pNextObj.asString() == "NULL")) return nullptr; + + parse_VkStructureType("sType", pNextObj["sType"], (o.sType)); + void* p = nullptr; + switch (o.sType) { +#ifdef VK_KHR_display_swapchain + case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: + { + p = s_globalMem.allocate(sizeof(VkDisplayPresentInfoKHR)); + parse_VkDisplayPresentInfoKHR("", pNextObj, *((VkDisplayPresentInfoKHR*)p)); + } + break; +#endif +#ifdef VK_EXT_validation_features + case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkValidationFeaturesEXT)); + parse_VkValidationFeaturesEXT("", pNextObj, *((VkValidationFeaturesEXT*)p)); + } + break; +#endif +#ifdef VK_EXT_application_parameters + case VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT: + { + p = s_globalMem.allocate(sizeof(VkApplicationParametersEXT)); + parse_VkApplicationParametersEXT("", pNextObj, *((VkApplicationParametersEXT*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_1 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceFeatures2)); + parse_VkPhysicalDeviceFeatures2("", pNextObj, *((VkPhysicalDeviceFeatures2*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceDriverProperties)); + parse_VkPhysicalDeviceDriverProperties("", pNextObj, *((VkPhysicalDeviceDriverProperties*)p)); + } + break; +#endif +#ifdef VK_KHR_incremental_present + case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: + { + p = s_globalMem.allocate(sizeof(VkPresentRegionsKHR)); + parse_VkPresentRegionsKHR("", pNextObj, *((VkPresentRegionsKHR*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_1 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceVariablePointersFeatures)); + parse_VkPhysicalDeviceVariablePointersFeatures("", pNextObj, *((VkPhysicalDeviceVariablePointersFeatures*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceExternalImageFormatInfo)); + parse_VkPhysicalDeviceExternalImageFormatInfo("", pNextObj, *((VkPhysicalDeviceExternalImageFormatInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: + { + p = s_globalMem.allocate(sizeof(VkExternalImageFormatProperties)); + parse_VkExternalImageFormatProperties("", pNextObj, *((VkExternalImageFormatProperties*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceIDProperties)); + parse_VkPhysicalDeviceIDProperties("", pNextObj, *((VkPhysicalDeviceIDProperties*)p)); + } + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkExternalMemoryImageCreateInfo)); + parse_VkExternalMemoryImageCreateInfo("", pNextObj, *((VkExternalMemoryImageCreateInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkExternalMemoryBufferCreateInfo)); + parse_VkExternalMemoryBufferCreateInfo("", pNextObj, *((VkExternalMemoryBufferCreateInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkExportMemoryAllocateInfo)); + parse_VkExportMemoryAllocateInfo("", pNextObj, *((VkExportMemoryAllocateInfo*)p)); + } + break; +#endif +#ifdef VK_KHR_external_memory_fd + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: + { + p = s_globalMem.allocate(sizeof(VkImportMemoryFdInfoKHR)); + parse_VkImportMemoryFdInfoKHR("", pNextObj, *((VkImportMemoryFdInfoKHR*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_1 + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkExportSemaphoreCreateInfo)); + parse_VkExportSemaphoreCreateInfo("", pNextObj, *((VkExportSemaphoreCreateInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkExportFenceCreateInfo)); + parse_VkExportFenceCreateInfo("", pNextObj, *((VkExportFenceCreateInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceMultiviewFeatures)); + parse_VkPhysicalDeviceMultiviewFeatures("", pNextObj, *((VkPhysicalDeviceMultiviewFeatures*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceMultiviewProperties)); + parse_VkPhysicalDeviceMultiviewProperties("", pNextObj, *((VkPhysicalDeviceMultiviewProperties*)p)); + } + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkRenderPassMultiviewCreateInfo)); + parse_VkRenderPassMultiviewCreateInfo("", pNextObj, *((VkRenderPassMultiviewCreateInfo*)p)); + } + break; +#endif +#ifdef VK_EXT_display_control + case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: + { + p = s_globalMem.allocate(sizeof(VkSwapchainCounterCreateInfoEXT)); + parse_VkSwapchainCounterCreateInfoEXT("", pNextObj, *((VkSwapchainCounterCreateInfoEXT*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_1 + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: + { + p = s_globalMem.allocate(sizeof(VkMemoryAllocateFlagsInfo)); + parse_VkMemoryAllocateFlagsInfo("", pNextObj, *((VkMemoryAllocateFlagsInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: + { + p = s_globalMem.allocate(sizeof(VkBindBufferMemoryDeviceGroupInfo)); + parse_VkBindBufferMemoryDeviceGroupInfo("", pNextObj, *((VkBindBufferMemoryDeviceGroupInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: + { + p = s_globalMem.allocate(sizeof(VkBindImageMemoryDeviceGroupInfo)); + parse_VkBindImageMemoryDeviceGroupInfo("", pNextObj, *((VkBindImageMemoryDeviceGroupInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: + { + p = s_globalMem.allocate(sizeof(VkDeviceGroupRenderPassBeginInfo)); + parse_VkDeviceGroupRenderPassBeginInfo("", pNextObj, *((VkDeviceGroupRenderPassBeginInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: + { + p = s_globalMem.allocate(sizeof(VkDeviceGroupCommandBufferBeginInfo)); + parse_VkDeviceGroupCommandBufferBeginInfo("", pNextObj, *((VkDeviceGroupCommandBufferBeginInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: + { + p = s_globalMem.allocate(sizeof(VkDeviceGroupSubmitInfo)); + parse_VkDeviceGroupSubmitInfo("", pNextObj, *((VkDeviceGroupSubmitInfo*)p)); + } + break; +#endif +#ifdef VK_KHR_swapchain + case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: + { + p = s_globalMem.allocate(sizeof(VkImageSwapchainCreateInfoKHR)); + parse_VkImageSwapchainCreateInfoKHR("", pNextObj, *((VkImageSwapchainCreateInfoKHR*)p)); + } + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: + { + p = s_globalMem.allocate(sizeof(VkBindImageMemorySwapchainInfoKHR)); + parse_VkBindImageMemorySwapchainInfoKHR("", pNextObj, *((VkBindImageMemorySwapchainInfoKHR*)p)); + } + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: + { + p = s_globalMem.allocate(sizeof(VkDeviceGroupPresentInfoKHR)); + parse_VkDeviceGroupPresentInfoKHR("", pNextObj, *((VkDeviceGroupPresentInfoKHR*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_1 + case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkDeviceGroupDeviceCreateInfo)); + parse_VkDeviceGroupDeviceCreateInfo("", pNextObj, *((VkDeviceGroupDeviceCreateInfo*)p)); + } + break; +#endif +#ifdef VK_KHR_swapchain + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: + { + p = s_globalMem.allocate(sizeof(VkDeviceGroupSwapchainCreateInfoKHR)); + parse_VkDeviceGroupSwapchainCreateInfoKHR("", pNextObj, *((VkDeviceGroupSwapchainCreateInfoKHR*)p)); + } + break; +#endif +#ifdef VK_EXT_discard_rectangles + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceDiscardRectanglePropertiesEXT)); + parse_VkPhysicalDeviceDiscardRectanglePropertiesEXT("", pNextObj, *((VkPhysicalDeviceDiscardRectanglePropertiesEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: + { + p = s_globalMem.allocate(sizeof(VkPipelineDiscardRectangleStateCreateInfoEXT)); + parse_VkPipelineDiscardRectangleStateCreateInfoEXT("", pNextObj, *((VkPipelineDiscardRectangleStateCreateInfoEXT*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_1 + case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkRenderPassInputAttachmentAspectCreateInfo)); + parse_VkRenderPassInputAttachmentAspectCreateInfo("", pNextObj, *((VkRenderPassInputAttachmentAspectCreateInfo*)p)); + } + break; +#endif +#ifdef VK_KHR_shared_presentable_image + case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: + { + p = s_globalMem.allocate(sizeof(VkSharedPresentSurfaceCapabilitiesKHR)); + parse_VkSharedPresentSurfaceCapabilitiesKHR("", pNextObj, *((VkSharedPresentSurfaceCapabilitiesKHR*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_1 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDevice16BitStorageFeatures)); + parse_VkPhysicalDevice16BitStorageFeatures("", pNextObj, *((VkPhysicalDevice16BitStorageFeatures*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceSubgroupProperties)); + parse_VkPhysicalDeviceSubgroupProperties("", pNextObj, *((VkPhysicalDeviceSubgroupProperties*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures)); + parse_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures("", pNextObj, *((VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_1 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDevicePointClippingProperties)); + parse_VkPhysicalDevicePointClippingProperties("", pNextObj, *((VkPhysicalDevicePointClippingProperties*)p)); + } + break; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: + { + p = s_globalMem.allocate(sizeof(VkMemoryDedicatedRequirements)); + parse_VkMemoryDedicatedRequirements("", pNextObj, *((VkMemoryDedicatedRequirements*)p)); + } + break; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkMemoryDedicatedAllocateInfo)); + parse_VkMemoryDedicatedAllocateInfo("", pNextObj, *((VkMemoryDedicatedAllocateInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkImageViewUsageCreateInfo)); + parse_VkImageViewUsageCreateInfo("", pNextObj, *((VkImageViewUsageCreateInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkPipelineTessellationDomainOriginStateCreateInfo)); + parse_VkPipelineTessellationDomainOriginStateCreateInfo("", pNextObj, *((VkPipelineTessellationDomainOriginStateCreateInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: + { + p = s_globalMem.allocate(sizeof(VkSamplerYcbcrConversionInfo)); + parse_VkSamplerYcbcrConversionInfo("", pNextObj, *((VkSamplerYcbcrConversionInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: + { + p = s_globalMem.allocate(sizeof(VkBindImagePlaneMemoryInfo)); + parse_VkBindImagePlaneMemoryInfo("", pNextObj, *((VkBindImagePlaneMemoryInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: + { + p = s_globalMem.allocate(sizeof(VkImagePlaneMemoryRequirementsInfo)); + parse_VkImagePlaneMemoryRequirementsInfo("", pNextObj, *((VkImagePlaneMemoryRequirementsInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures)); + parse_VkPhysicalDeviceSamplerYcbcrConversionFeatures("", pNextObj, *((VkPhysicalDeviceSamplerYcbcrConversionFeatures*)p)); + } + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: + { + p = s_globalMem.allocate(sizeof(VkSamplerYcbcrConversionImageFormatProperties)); + parse_VkSamplerYcbcrConversionImageFormatProperties("", pNextObj, *((VkSamplerYcbcrConversionImageFormatProperties*)p)); + } + break; + case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: + { + p = s_globalMem.allocate(sizeof(VkProtectedSubmitInfo)); + parse_VkProtectedSubmitInfo("", pNextObj, *((VkProtectedSubmitInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceProtectedMemoryFeatures)); + parse_VkPhysicalDeviceProtectedMemoryFeatures("", pNextObj, *((VkPhysicalDeviceProtectedMemoryFeatures*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceProtectedMemoryProperties)); + parse_VkPhysicalDeviceProtectedMemoryProperties("", pNextObj, *((VkPhysicalDeviceProtectedMemoryProperties*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceSamplerFilterMinmaxProperties)); + parse_VkPhysicalDeviceSamplerFilterMinmaxProperties("", pNextObj, *((VkPhysicalDeviceSamplerFilterMinmaxProperties*)p)); + } + break; +#endif +#ifdef VK_EXT_sample_locations + case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: + { + p = s_globalMem.allocate(sizeof(VkSampleLocationsInfoEXT)); + parse_VkSampleLocationsInfoEXT("", pNextObj, *((VkSampleLocationsInfoEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: + { + p = s_globalMem.allocate(sizeof(VkRenderPassSampleLocationsBeginInfoEXT)); + parse_VkRenderPassSampleLocationsBeginInfoEXT("", pNextObj, *((VkRenderPassSampleLocationsBeginInfoEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: + { + p = s_globalMem.allocate(sizeof(VkPipelineSampleLocationsStateCreateInfoEXT)); + parse_VkPipelineSampleLocationsStateCreateInfoEXT("", pNextObj, *((VkPipelineSampleLocationsStateCreateInfoEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceSampleLocationsPropertiesEXT)); + parse_VkPhysicalDeviceSampleLocationsPropertiesEXT("", pNextObj, *((VkPhysicalDeviceSampleLocationsPropertiesEXT*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkSamplerReductionModeCreateInfo)); + parse_VkSamplerReductionModeCreateInfo("", pNextObj, *((VkSamplerReductionModeCreateInfo*)p)); + } + break; +#endif +#ifdef VK_EXT_blend_operation_advanced + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT)); + parse_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT("", pNextObj, *((VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT)); + parse_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT("", pNextObj, *((VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: + { + p = s_globalMem.allocate(sizeof(VkPipelineColorBlendAdvancedStateCreateInfoEXT)); + parse_VkPipelineColorBlendAdvancedStateCreateInfoEXT("", pNextObj, *((VkPipelineColorBlendAdvancedStateCreateInfoEXT*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkImageFormatListCreateInfo)); + parse_VkImageFormatListCreateInfo("", pNextObj, *((VkImageFormatListCreateInfo*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_1 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceMaintenance3Properties)); + parse_VkPhysicalDeviceMaintenance3Properties("", pNextObj, *((VkPhysicalDeviceMaintenance3Properties*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceShaderDrawParametersFeatures)); + parse_VkPhysicalDeviceShaderDrawParametersFeatures("", pNextObj, *((VkPhysicalDeviceShaderDrawParametersFeatures*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceShaderFloat16Int8Features)); + parse_VkPhysicalDeviceShaderFloat16Int8Features("", pNextObj, *((VkPhysicalDeviceShaderFloat16Int8Features*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceFloatControlsProperties)); + parse_VkPhysicalDeviceFloatControlsProperties("", pNextObj, *((VkPhysicalDeviceFloatControlsProperties*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceHostQueryResetFeatures)); + parse_VkPhysicalDeviceHostQueryResetFeatures("", pNextObj, *((VkPhysicalDeviceHostQueryResetFeatures*)p)); + } + break; +#endif +#ifdef VK_EXT_global_priority + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: + { + p = s_globalMem.allocate(sizeof(VkDeviceQueueGlobalPriorityCreateInfoEXT)); + parse_VkDeviceQueueGlobalPriorityCreateInfoEXT("", pNextObj, *((VkDeviceQueueGlobalPriorityCreateInfoEXT*)p)); + } + break; +#endif +#ifdef VK_EXT_debug_utils + case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: + { + p = s_globalMem.allocate(sizeof(VkDebugUtilsMessengerCreateInfoEXT)); + parse_VkDebugUtilsMessengerCreateInfoEXT("", pNextObj, *((VkDebugUtilsMessengerCreateInfoEXT*)p)); + } + break; +#endif +#ifdef VK_EXT_external_memory_host + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: + { + p = s_globalMem.allocate(sizeof(VkImportMemoryHostPointerInfoEXT)); + parse_VkImportMemoryHostPointerInfoEXT("", pNextObj, *((VkImportMemoryHostPointerInfoEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceExternalMemoryHostPropertiesEXT)); + parse_VkPhysicalDeviceExternalMemoryHostPropertiesEXT("", pNextObj, *((VkPhysicalDeviceExternalMemoryHostPropertiesEXT*)p)); + } + break; +#endif +#ifdef VK_EXT_conservative_rasterization + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceConservativeRasterizationPropertiesEXT)); + parse_VkPhysicalDeviceConservativeRasterizationPropertiesEXT("", pNextObj, *((VkPhysicalDeviceConservativeRasterizationPropertiesEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: + { + p = s_globalMem.allocate(sizeof(VkPipelineRasterizationConservativeStateCreateInfoEXT)); + parse_VkPipelineRasterizationConservativeStateCreateInfoEXT("", pNextObj, *((VkPipelineRasterizationConservativeStateCreateInfoEXT*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceDescriptorIndexingFeatures)); + parse_VkPhysicalDeviceDescriptorIndexingFeatures("", pNextObj, *((VkPhysicalDeviceDescriptorIndexingFeatures*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceDescriptorIndexingProperties)); + parse_VkPhysicalDeviceDescriptorIndexingProperties("", pNextObj, *((VkPhysicalDeviceDescriptorIndexingProperties*)p)); + } + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkDescriptorSetLayoutBindingFlagsCreateInfo)); + parse_VkDescriptorSetLayoutBindingFlagsCreateInfo("", pNextObj, *((VkDescriptorSetLayoutBindingFlagsCreateInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkDescriptorSetVariableDescriptorCountAllocateInfo)); + parse_VkDescriptorSetVariableDescriptorCountAllocateInfo("", pNextObj, *((VkDescriptorSetVariableDescriptorCountAllocateInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: + { + p = s_globalMem.allocate(sizeof(VkDescriptorSetVariableDescriptorCountLayoutSupport)); + parse_VkDescriptorSetVariableDescriptorCountLayoutSupport("", pNextObj, *((VkDescriptorSetVariableDescriptorCountLayoutSupport*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceTimelineSemaphoreFeatures)); + parse_VkPhysicalDeviceTimelineSemaphoreFeatures("", pNextObj, *((VkPhysicalDeviceTimelineSemaphoreFeatures*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceTimelineSemaphoreProperties)); + parse_VkPhysicalDeviceTimelineSemaphoreProperties("", pNextObj, *((VkPhysicalDeviceTimelineSemaphoreProperties*)p)); + } + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkSemaphoreTypeCreateInfo)); + parse_VkSemaphoreTypeCreateInfo("", pNextObj, *((VkSemaphoreTypeCreateInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: + { + p = s_globalMem.allocate(sizeof(VkTimelineSemaphoreSubmitInfo)); + parse_VkTimelineSemaphoreSubmitInfo("", pNextObj, *((VkTimelineSemaphoreSubmitInfo*)p)); + } + break; +#endif +#ifdef VK_EXT_vertex_attribute_divisor + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: + { + p = s_globalMem.allocate(sizeof(VkPipelineVertexInputDivisorStateCreateInfoEXT)); + parse_VkPipelineVertexInputDivisorStateCreateInfoEXT("", pNextObj, *((VkPipelineVertexInputDivisorStateCreateInfoEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT)); + parse_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT("", pNextObj, *((VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*)p)); + } + break; +#endif +#ifdef VK_EXT_pci_bus_info + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDevicePCIBusInfoPropertiesEXT)); + parse_VkPhysicalDevicePCIBusInfoPropertiesEXT("", pNextObj, *((VkPhysicalDevicePCIBusInfoPropertiesEXT*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDevice8BitStorageFeatures)); + parse_VkPhysicalDevice8BitStorageFeatures("", pNextObj, *((VkPhysicalDevice8BitStorageFeatures*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceVulkanMemoryModelFeatures)); + parse_VkPhysicalDeviceVulkanMemoryModelFeatures("", pNextObj, *((VkPhysicalDeviceVulkanMemoryModelFeatures*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceShaderAtomicInt64Features)); + parse_VkPhysicalDeviceShaderAtomicInt64Features("", pNextObj, *((VkPhysicalDeviceShaderAtomicInt64Features*)p)); + } + break; +#endif +#ifdef VK_EXT_shader_atomic_float + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT)); + parse_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT("", pNextObj, *((VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*)p)); + } + break; +#endif +#ifdef VK_EXT_vertex_attribute_divisor + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT)); + parse_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT("", pNextObj, *((VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceDepthStencilResolveProperties)); + parse_VkPhysicalDeviceDepthStencilResolveProperties("", pNextObj, *((VkPhysicalDeviceDepthStencilResolveProperties*)p)); + } + break; + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: + { + p = s_globalMem.allocate(sizeof(VkSubpassDescriptionDepthStencilResolve)); + parse_VkSubpassDescriptionDepthStencilResolve("", pNextObj, *((VkSubpassDescriptionDepthStencilResolve*)p)); + } + break; +#endif +#ifdef VK_EXT_astc_decode_mode + case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: + { + p = s_globalMem.allocate(sizeof(VkImageViewASTCDecodeModeEXT)); + parse_VkImageViewASTCDecodeModeEXT("", pNextObj, *((VkImageViewASTCDecodeModeEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceASTCDecodeFeaturesEXT)); + parse_VkPhysicalDeviceASTCDecodeFeaturesEXT("", pNextObj, *((VkPhysicalDeviceASTCDecodeFeaturesEXT*)p)); + } + break; +#endif +#ifdef VK_EXT_image_drm_format_modifier + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: + { + p = s_globalMem.allocate(sizeof(VkDrmFormatModifierPropertiesListEXT)); + parse_VkDrmFormatModifierPropertiesListEXT("", pNextObj, *((VkDrmFormatModifierPropertiesListEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceImageDrmFormatModifierInfoEXT)); + parse_VkPhysicalDeviceImageDrmFormatModifierInfoEXT("", pNextObj, *((VkPhysicalDeviceImageDrmFormatModifierInfoEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: + { + p = s_globalMem.allocate(sizeof(VkImageDrmFormatModifierListCreateInfoEXT)); + parse_VkImageDrmFormatModifierListCreateInfoEXT("", pNextObj, *((VkImageDrmFormatModifierListCreateInfoEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: + { + p = s_globalMem.allocate(sizeof(VkImageDrmFormatModifierExplicitCreateInfoEXT)); + parse_VkImageDrmFormatModifierExplicitCreateInfoEXT("", pNextObj, *((VkImageDrmFormatModifierExplicitCreateInfoEXT*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkImageStencilUsageCreateInfo)); + parse_VkImageStencilUsageCreateInfo("", pNextObj, *((VkImageStencilUsageCreateInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceScalarBlockLayoutFeatures)); + parse_VkPhysicalDeviceScalarBlockLayoutFeatures("", pNextObj, *((VkPhysicalDeviceScalarBlockLayoutFeatures*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceUniformBufferStandardLayoutFeatures)); + parse_VkPhysicalDeviceUniformBufferStandardLayoutFeatures("", pNextObj, *((VkPhysicalDeviceUniformBufferStandardLayoutFeatures*)p)); + } + break; +#endif +#ifdef VK_EXT_depth_clip_enable + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceDepthClipEnableFeaturesEXT)); + parse_VkPhysicalDeviceDepthClipEnableFeaturesEXT("", pNextObj, *((VkPhysicalDeviceDepthClipEnableFeaturesEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: + { + p = s_globalMem.allocate(sizeof(VkPipelineRasterizationDepthClipStateCreateInfoEXT)); + parse_VkPipelineRasterizationDepthClipStateCreateInfoEXT("", pNextObj, *((VkPipelineRasterizationDepthClipStateCreateInfoEXT*)p)); + } + break; +#endif +#ifdef VK_EXT_memory_budget + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceMemoryBudgetPropertiesEXT)); + parse_VkPhysicalDeviceMemoryBudgetPropertiesEXT("", pNextObj, *((VkPhysicalDeviceMemoryBudgetPropertiesEXT*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceBufferDeviceAddressFeatures)); + parse_VkPhysicalDeviceBufferDeviceAddressFeatures("", pNextObj, *((VkPhysicalDeviceBufferDeviceAddressFeatures*)p)); + } + break; + case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkBufferOpaqueCaptureAddressCreateInfo)); + parse_VkBufferOpaqueCaptureAddressCreateInfo("", pNextObj, *((VkBufferOpaqueCaptureAddressCreateInfo*)p)); + } + break; +#endif +#ifdef VK_EXT_filter_cubic + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceImageViewImageFormatInfoEXT)); + parse_VkPhysicalDeviceImageViewImageFormatInfoEXT("", pNextObj, *((VkPhysicalDeviceImageViewImageFormatInfoEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: + { + p = s_globalMem.allocate(sizeof(VkFilterCubicImageViewImageFormatPropertiesEXT)); + parse_VkFilterCubicImageViewImageFormatPropertiesEXT("", pNextObj, *((VkFilterCubicImageViewImageFormatPropertiesEXT*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceImagelessFramebufferFeatures)); + parse_VkPhysicalDeviceImagelessFramebufferFeatures("", pNextObj, *((VkPhysicalDeviceImagelessFramebufferFeatures*)p)); + } + break; + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkFramebufferAttachmentsCreateInfo)); + parse_VkFramebufferAttachmentsCreateInfo("", pNextObj, *((VkFramebufferAttachmentsCreateInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: + { + p = s_globalMem.allocate(sizeof(VkRenderPassAttachmentBeginInfo)); + parse_VkRenderPassAttachmentBeginInfo("", pNextObj, *((VkRenderPassAttachmentBeginInfo*)p)); + } + break; +#endif +#ifdef VK_EXT_texture_compression_astc_hdr + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)); + parse_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT("", pNextObj, *((VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*)p)); + } + break; +#endif +#ifdef VK_EXT_ycbcr_image_arrays + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT)); + parse_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT("", pNextObj, *((VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*)p)); + } + break; +#endif +#ifdef VK_KHR_performance_query + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDevicePerformanceQueryFeaturesKHR)); + parse_VkPhysicalDevicePerformanceQueryFeaturesKHR("", pNextObj, *((VkPhysicalDevicePerformanceQueryFeaturesKHR*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDevicePerformanceQueryPropertiesKHR)); + parse_VkPhysicalDevicePerformanceQueryPropertiesKHR("", pNextObj, *((VkPhysicalDevicePerformanceQueryPropertiesKHR*)p)); + } + break; + case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: + { + p = s_globalMem.allocate(sizeof(VkQueryPoolPerformanceCreateInfoKHR)); + parse_VkQueryPoolPerformanceCreateInfoKHR("", pNextObj, *((VkQueryPoolPerformanceCreateInfoKHR*)p)); + } + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: + { + p = s_globalMem.allocate(sizeof(VkPerformanceQuerySubmitInfoKHR)); + parse_VkPerformanceQuerySubmitInfoKHR("", pNextObj, *((VkPerformanceQuerySubmitInfoKHR*)p)); + } + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR: + { + p = s_globalMem.allocate(sizeof(VkPerformanceQueryReservationInfoKHR)); + parse_VkPerformanceQueryReservationInfoKHR("", pNextObj, *((VkPerformanceQueryReservationInfoKHR*)p)); + } + break; +#endif +#ifdef VK_KHR_shader_clock + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceShaderClockFeaturesKHR)); + parse_VkPhysicalDeviceShaderClockFeaturesKHR("", pNextObj, *((VkPhysicalDeviceShaderClockFeaturesKHR*)p)); + } + break; +#endif +#ifdef VK_EXT_index_type_uint8 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceIndexTypeUint8FeaturesEXT)); + parse_VkPhysicalDeviceIndexTypeUint8FeaturesEXT("", pNextObj, *((VkPhysicalDeviceIndexTypeUint8FeaturesEXT*)p)); + } + break; +#endif +#ifdef VK_EXT_fragment_shader_interlock + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT)); + parse_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT("", pNextObj, *((VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures)); + parse_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures("", pNextObj, *((VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*)p)); + } + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: + { + p = s_globalMem.allocate(sizeof(VkAttachmentReferenceStencilLayout)); + parse_VkAttachmentReferenceStencilLayout("", pNextObj, *((VkAttachmentReferenceStencilLayout*)p)); + } + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: + { + p = s_globalMem.allocate(sizeof(VkAttachmentDescriptionStencilLayout)); + parse_VkAttachmentDescriptionStencilLayout("", pNextObj, *((VkAttachmentDescriptionStencilLayout*)p)); + } + break; +#endif +#ifdef VK_EXT_shader_demote_to_helper_invocation + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT)); + parse_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT("", pNextObj, *((VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*)p)); + } + break; +#endif +#ifdef VK_EXT_texel_buffer_alignment + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT)); + parse_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT("", pNextObj, *((VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT)); + parse_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT("", pNextObj, *((VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*)p)); + } + break; +#endif +#ifdef VK_EXT_subgroup_size_control + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceSubgroupSizeControlFeaturesEXT)); + parse_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT("", pNextObj, *((VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceSubgroupSizeControlPropertiesEXT)); + parse_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT("", pNextObj, *((VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: + { + p = s_globalMem.allocate(sizeof(VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT)); + parse_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT("", pNextObj, *((VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkMemoryOpaqueCaptureAddressAllocateInfo)); + parse_VkMemoryOpaqueCaptureAddressAllocateInfo("", pNextObj, *((VkMemoryOpaqueCaptureAddressAllocateInfo*)p)); + } + break; +#endif +#ifdef VK_EXT_line_rasterization + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceLineRasterizationFeaturesEXT)); + parse_VkPhysicalDeviceLineRasterizationFeaturesEXT("", pNextObj, *((VkPhysicalDeviceLineRasterizationFeaturesEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceLineRasterizationPropertiesEXT)); + parse_VkPhysicalDeviceLineRasterizationPropertiesEXT("", pNextObj, *((VkPhysicalDeviceLineRasterizationPropertiesEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: + { + p = s_globalMem.allocate(sizeof(VkPipelineRasterizationLineStateCreateInfoEXT)); + parse_VkPipelineRasterizationLineStateCreateInfoEXT("", pNextObj, *((VkPipelineRasterizationLineStateCreateInfoEXT*)p)); + } + break; +#endif +#ifdef VK_VERSION_1_2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceVulkan11Features)); + parse_VkPhysicalDeviceVulkan11Features("", pNextObj, *((VkPhysicalDeviceVulkan11Features*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceVulkan11Properties)); + parse_VkPhysicalDeviceVulkan11Properties("", pNextObj, *((VkPhysicalDeviceVulkan11Properties*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceVulkan12Features)); + parse_VkPhysicalDeviceVulkan12Features("", pNextObj, *((VkPhysicalDeviceVulkan12Features*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceVulkan12Properties)); + parse_VkPhysicalDeviceVulkan12Properties("", pNextObj, *((VkPhysicalDeviceVulkan12Properties*)p)); + } + break; +#endif +#ifdef VKSC_VERSION_1_0 + case VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO: + { + p = s_globalMem.allocate(sizeof(VkFaultCallbackInfo)); + parse_VkFaultCallbackInfo("", pNextObj, *((VkFaultCallbackInfo*)p)); + } + break; +#endif +#ifdef VK_EXT_custom_border_color + case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: + { + p = s_globalMem.allocate(sizeof(VkSamplerCustomBorderColorCreateInfoEXT)); + parse_VkSamplerCustomBorderColorCreateInfoEXT("", pNextObj, *((VkSamplerCustomBorderColorCreateInfoEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceCustomBorderColorPropertiesEXT)); + parse_VkPhysicalDeviceCustomBorderColorPropertiesEXT("", pNextObj, *((VkPhysicalDeviceCustomBorderColorPropertiesEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceCustomBorderColorFeaturesEXT)); + parse_VkPhysicalDeviceCustomBorderColorFeaturesEXT("", pNextObj, *((VkPhysicalDeviceCustomBorderColorFeaturesEXT*)p)); + } + break; +#endif +#ifdef VK_EXT_extended_dynamic_state + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT)); + parse_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT("", pNextObj, *((VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*)p)); + } + break; +#endif +#ifdef VK_EXT_extended_dynamic_state2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT)); + parse_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT("", pNextObj, *((VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*)p)); + } + break; +#endif +#ifdef VKSC_VERSION_1_0 + case VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkPipelineOfflineCreateInfo)); + parse_VkPipelineOfflineCreateInfo("", pNextObj, *((VkPipelineOfflineCreateInfo*)p)); + } + break; +#endif +#ifdef VK_EXT_robustness2 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceRobustness2FeaturesEXT)); + parse_VkPhysicalDeviceRobustness2FeaturesEXT("", pNextObj, *((VkPhysicalDeviceRobustness2FeaturesEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceRobustness2PropertiesEXT)); + parse_VkPhysicalDeviceRobustness2PropertiesEXT("", pNextObj, *((VkPhysicalDeviceRobustness2PropertiesEXT*)p)); + } + break; +#endif +#ifdef VK_EXT_image_robustness + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceImageRobustnessFeaturesEXT)); + parse_VkPhysicalDeviceImageRobustnessFeaturesEXT("", pNextObj, *((VkPhysicalDeviceImageRobustnessFeaturesEXT*)p)); + } + break; +#endif +#ifdef VK_EXT_4444_formats + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDevice4444FormatsFeaturesEXT)); + parse_VkPhysicalDevice4444FormatsFeaturesEXT("", pNextObj, *((VkPhysicalDevice4444FormatsFeaturesEXT*)p)); + } + break; +#endif +#ifdef VK_EXT_shader_image_atomic_int64 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT)); + parse_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT("", pNextObj, *((VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*)p)); + } + break; +#endif +#ifdef VK_KHR_fragment_shading_rate + case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: + { + p = s_globalMem.allocate(sizeof(VkFragmentShadingRateAttachmentInfoKHR)); + parse_VkFragmentShadingRateAttachmentInfoKHR("", pNextObj, *((VkFragmentShadingRateAttachmentInfoKHR*)p)); + } + break; + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: + { + p = s_globalMem.allocate(sizeof(VkPipelineFragmentShadingRateStateCreateInfoKHR)); + parse_VkPipelineFragmentShadingRateStateCreateInfoKHR("", pNextObj, *((VkPipelineFragmentShadingRateStateCreateInfoKHR*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceFragmentShadingRateFeaturesKHR)); + parse_VkPhysicalDeviceFragmentShadingRateFeaturesKHR("", pNextObj, *((VkPhysicalDeviceFragmentShadingRateFeaturesKHR*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceFragmentShadingRatePropertiesKHR)); + parse_VkPhysicalDeviceFragmentShadingRatePropertiesKHR("", pNextObj, *((VkPhysicalDeviceFragmentShadingRatePropertiesKHR*)p)); + } + break; +#endif +#ifdef VK_KHR_shader_terminate_invocation + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR)); + parse_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR("", pNextObj, *((VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*)p)); + } + break; +#endif +#ifdef VK_EXT_vertex_input_dynamic_state + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT)); + parse_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT("", pNextObj, *((VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*)p)); + } + break; +#endif +#ifdef VK_EXT_color_write_enable + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceColorWriteEnableFeaturesEXT)); + parse_VkPhysicalDeviceColorWriteEnableFeaturesEXT("", pNextObj, *((VkPhysicalDeviceColorWriteEnableFeaturesEXT*)p)); + } + break; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: + { + p = s_globalMem.allocate(sizeof(VkPipelineColorWriteCreateInfoEXT)); + parse_VkPipelineColorWriteCreateInfoEXT("", pNextObj, *((VkPipelineColorWriteCreateInfoEXT*)p)); + } + break; +#endif +#ifdef VK_KHR_synchronization2 + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: + { + p = s_globalMem.allocate(sizeof(VkMemoryBarrier2KHR)); + parse_VkMemoryBarrier2KHR("", pNextObj, *((VkMemoryBarrier2KHR*)p)); + } + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: + { + p = s_globalMem.allocate(sizeof(VkQueueFamilyCheckpointProperties2NV)); + parse_VkQueueFamilyCheckpointProperties2NV("", pNextObj, *((VkQueueFamilyCheckpointProperties2NV*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceSynchronization2FeaturesKHR)); + parse_VkPhysicalDeviceSynchronization2FeaturesKHR("", pNextObj, *((VkPhysicalDeviceSynchronization2FeaturesKHR*)p)); + } + break; +#endif +#ifdef VKSC_VERSION_1_0 + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceVulkanSC10Properties)); + parse_VkPhysicalDeviceVulkanSC10Properties("", pNextObj, *((VkPhysicalDeviceVulkanSC10Properties*)p)); + } + break; + case VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkDeviceObjectReservationCreateInfo)); + parse_VkDeviceObjectReservationCreateInfo("", pNextObj, *((VkDeviceObjectReservationCreateInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO: + { + p = s_globalMem.allocate(sizeof(VkCommandPoolMemoryReservationCreateInfo)); + parse_VkCommandPoolMemoryReservationCreateInfo("", pNextObj, *((VkCommandPoolMemoryReservationCreateInfo*)p)); + } + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceVulkanSC10Features)); + parse_VkPhysicalDeviceVulkanSC10Features("", pNextObj, *((VkPhysicalDeviceVulkanSC10Features*)p)); + } + break; +#endif +#ifdef VK_EXT_ycbcr_2plane_444_formats + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: + { + p = s_globalMem.allocate(sizeof(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT)); + parse_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT("", pNextObj, *((VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*)p)); + } + break; +#endif +#ifdef VK_EXT_image_drm_format_modifier + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: + { + p = s_globalMem.allocate(sizeof(VkDrmFormatModifierPropertiesList2EXT)); + parse_VkDrmFormatModifierPropertiesList2EXT("", pNextObj, *((VkDrmFormatModifierPropertiesList2EXT*)p)); + } + break; +#endif + default: {/** **/} + } + return p; + } + +static void parse_VkBool32(const char* s, Json::Value& obj, VkBool32& o) { + std::string _res = obj.asString(); + //VkBool is represented as VK_TRUE and VK_FALSE in the json + o = (_res == "VK_TRUE") ? (1) : (0); +} + +static void parse_VkDeviceAddress(const char* s, Json::Value& obj, VkDeviceAddress& o) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%" SCNu64, &o); +} + +static void parse_VkDeviceSize(const char* s, Json::Value& obj, VkDeviceSize& o) { + std::string _res = obj.asString(); + if (_res == "VK_WHOLE_SIZE") + o = (~0ULL); + else + sscanf(_res.c_str(), "%" SCNu64, &o); +} + +static void parse_VkFlags(const char* s, Json::Value& obj, VkFlags& o) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); +} + +static void parse_VkSampleMask(const char* s, Json::Value& obj, VkSampleMask& o) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); +} + +static void parse_VkBuffer(const char* s, Json::Value& obj, VkBuffer& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkImage(const char* s, Json::Value& obj, VkImage& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkInstance(const char* s, Json::Value& obj, VkInstance& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkPhysicalDevice(const char* s, Json::Value& obj, VkPhysicalDevice& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkDevice(const char* s, Json::Value& obj, VkDevice& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkQueue(const char* s, Json::Value& obj, VkQueue& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkSemaphore(const char* s, Json::Value& obj, VkSemaphore& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkCommandBuffer(const char* s, Json::Value& obj, VkCommandBuffer& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkFence(const char* s, Json::Value& obj, VkFence& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkDeviceMemory(const char* s, Json::Value& obj, VkDeviceMemory& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkEvent(const char* s, Json::Value& obj, VkEvent& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkQueryPool(const char* s, Json::Value& obj, VkQueryPool& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkBufferView(const char* s, Json::Value& obj, VkBufferView& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkImageView(const char* s, Json::Value& obj, VkImageView& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkShaderModule(const char* s, Json::Value& obj, VkShaderModule& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkPipelineCache(const char* s, Json::Value& obj, VkPipelineCache& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkPipelineLayout(const char* s, Json::Value& obj, VkPipelineLayout& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkPipeline(const char* s, Json::Value& obj, VkPipeline& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkRenderPass(const char* s, Json::Value& obj, VkRenderPass& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkDescriptorSetLayout(const char* s, Json::Value& obj, VkDescriptorSetLayout& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkSampler(const char* s, Json::Value& obj, VkSampler& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkDescriptorSet(const char* s, Json::Value& obj, VkDescriptorSet& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkDescriptorPool(const char* s, Json::Value& obj, VkDescriptorPool& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkFramebuffer(const char* s, Json::Value& obj, VkFramebuffer& o) { +// std::string _res = obj.asString(); +} + +static void parse_VkCommandPool(const char* s, Json::Value& obj, VkCommandPool& o) { +// std::string _res = obj.asString(); +} + +static std::map VkResult_map = { + std::make_pair("VK_SUCCESS", 0), + std::make_pair("VK_NOT_READY", 1), + std::make_pair("VK_TIMEOUT", 2), + std::make_pair("VK_EVENT_SET", 3), + std::make_pair("VK_EVENT_RESET", 4), + std::make_pair("VK_INCOMPLETE", 5), + std::make_pair("VK_ERROR_OUT_OF_HOST_MEMORY", -1), + std::make_pair("VK_ERROR_OUT_OF_DEVICE_MEMORY", -2), + std::make_pair("VK_ERROR_INITIALIZATION_FAILED", -3), + std::make_pair("VK_ERROR_DEVICE_LOST", -4), + std::make_pair("VK_ERROR_MEMORY_MAP_FAILED", -5), + std::make_pair("VK_ERROR_LAYER_NOT_PRESENT", -6), + std::make_pair("VK_ERROR_EXTENSION_NOT_PRESENT", -7), + std::make_pair("VK_ERROR_FEATURE_NOT_PRESENT", -8), + std::make_pair("VK_ERROR_INCOMPATIBLE_DRIVER", -9), + std::make_pair("VK_ERROR_TOO_MANY_OBJECTS", -10), + std::make_pair("VK_ERROR_FORMAT_NOT_SUPPORTED", -11), + std::make_pair("VK_ERROR_FRAGMENTED_POOL", -12), + std::make_pair("VK_ERROR_UNKNOWN", -13), + std::make_pair("VK_ERROR_OUT_OF_POOL_MEMORY", 1000069000), + std::make_pair("VK_ERROR_INVALID_EXTERNAL_HANDLE", 1000072003), + std::make_pair("VK_ERROR_FRAGMENTATION", 1000161000), + std::make_pair("VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS", 1000257000), + std::make_pair("VK_ERROR_VALIDATION_FAILED", 1000011001), + std::make_pair("VK_ERROR_INVALID_PIPELINE_CACHE_DATA", 1000298000), + std::make_pair("VK_ERROR_NO_PIPELINE_MATCH", 1000298001), + std::make_pair("VK_ERROR_SURFACE_LOST_KHR", 1000000000), + std::make_pair("VK_ERROR_NATIVE_WINDOW_IN_USE_KHR", 1000000001), + std::make_pair("VK_SUBOPTIMAL_KHR", 1000001003), + std::make_pair("VK_ERROR_OUT_OF_DATE_KHR", 1000001004), + std::make_pair("VK_ERROR_INCOMPATIBLE_DISPLAY_KHR", 1000003001), + std::make_pair("VK_ERROR_INVALID_SHADER_NV", 1000012000), + std::make_pair("VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT", 1000158000), + std::make_pair("VK_ERROR_NOT_PERMITTED_EXT", 1000174001), + std::make_pair("VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT", 1000255000), + std::make_pair("VK_THREAD_IDLE_KHR", 1000268000), + std::make_pair("VK_THREAD_DONE_KHR", 1000268001), + std::make_pair("VK_OPERATION_DEFERRED_KHR", 1000268002), + std::make_pair("VK_OPERATION_NOT_DEFERRED_KHR", 1000268003), + std::make_pair("VK_PIPELINE_COMPILE_REQUIRED_EXT", 1000297000), +}; +static void parse_VkResult(const char* s, Json::Value& obj, VkResult& o) { + std::string _res = obj.asString(); + o = (VkResult)VkResult_map[std::string(_res)]; +} + +static std::map VkStructureType_map = { + std::make_pair("VK_STRUCTURE_TYPE_APPLICATION_INFO", 0), + std::make_pair("VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO", 1), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO", 2), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO", 3), + std::make_pair("VK_STRUCTURE_TYPE_SUBMIT_INFO", 4), + std::make_pair("VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO", 5), + std::make_pair("VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE", 6), + std::make_pair("VK_STRUCTURE_TYPE_FENCE_CREATE_INFO", 8), + std::make_pair("VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO", 9), + std::make_pair("VK_STRUCTURE_TYPE_EVENT_CREATE_INFO", 10), + std::make_pair("VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO", 11), + std::make_pair("VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO", 12), + std::make_pair("VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO", 13), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO", 14), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO", 15), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO", 17), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO", 18), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO", 19), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO", 20), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO", 21), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO", 22), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO", 23), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO", 24), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO", 25), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO", 26), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO", 27), + std::make_pair("VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO", 28), + std::make_pair("VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO", 29), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO", 30), + std::make_pair("VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO", 31), + std::make_pair("VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO", 32), + std::make_pair("VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO", 33), + std::make_pair("VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO", 34), + std::make_pair("VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET", 35), + std::make_pair("VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET", 36), + std::make_pair("VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO", 37), + std::make_pair("VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO", 38), + std::make_pair("VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO", 39), + std::make_pair("VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO", 40), + std::make_pair("VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO", 41), + std::make_pair("VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO", 42), + std::make_pair("VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO", 43), + std::make_pair("VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER", 44), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER", 45), + std::make_pair("VK_STRUCTURE_TYPE_MEMORY_BARRIER", 46), + std::make_pair("VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO", 47), + std::make_pair("VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO", 48), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES", 1000094000), + std::make_pair("VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO", 1000157000), + std::make_pair("VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO", 1000157001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES", 1000083000), + std::make_pair("VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS", 1000127000), + std::make_pair("VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO", 1000127001), + std::make_pair("VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO", 1000060000), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO", 1000060003), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO", 1000060004), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO", 1000060005), + std::make_pair("VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO", 1000060013), + std::make_pair("VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO", 1000060014), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES", 1000070000), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO", 1000070001), + std::make_pair("VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2", 1000146000), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2", 1000146001), + std::make_pair("VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2", 1000146003), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2", 1000059000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2", 1000059001), + std::make_pair("VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2", 1000059002), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2", 1000059003), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2", 1000059004), + std::make_pair("VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2", 1000059005), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2", 1000059006), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES", 1000117000), + std::make_pair("VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO", 1000117001), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO", 1000117002), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO", 1000117003), + std::make_pair("VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO", 1000053000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES", 1000053001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES", 1000053002), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES", 1000120000), + std::make_pair("VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO", 1000145000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES", 1000145001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES", 1000145002), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2", 1000145003), + std::make_pair("VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO", 1000156000), + std::make_pair("VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO", 1000156001), + std::make_pair("VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO", 1000156002), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO", 1000156003), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES", 1000156004), + std::make_pair("VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES", 1000156005), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO", 1000071000), + std::make_pair("VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES", 1000071001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO", 1000071002), + std::make_pair("VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES", 1000071003), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES", 1000071004), + std::make_pair("VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO", 1000072000), + std::make_pair("VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO", 1000072001), + std::make_pair("VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO", 1000072002), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO", 1000112000), + std::make_pair("VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES", 1000112001), + std::make_pair("VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO", 1000113000), + std::make_pair("VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO", 1000077000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO", 1000076000), + std::make_pair("VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES", 1000076001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES", 1000168000), + std::make_pair("VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT", 1000168001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES", 1000063000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES", 49), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES", 50), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES", 51), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES", 52), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO", 1000147000), + std::make_pair("VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2", 1000109000), + std::make_pair("VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2", 1000109001), + std::make_pair("VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2", 1000109002), + std::make_pair("VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2", 1000109003), + std::make_pair("VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2", 1000109004), + std::make_pair("VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO", 1000109005), + std::make_pair("VK_STRUCTURE_TYPE_SUBPASS_END_INFO", 1000109006), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES", 1000177000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES", 1000196000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES", 1000180000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES", 1000082000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES", 1000197000), + std::make_pair("VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO", 1000161000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES", 1000161001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES", 1000161002), + std::make_pair("VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO", 1000161003), + std::make_pair("VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT", 1000161004), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES", 1000199000), + std::make_pair("VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE", 1000199001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES", 1000221000), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO", 1000246000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES", 1000130000), + std::make_pair("VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO", 1000130001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES", 1000211000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES", 1000108000), + std::make_pair("VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO", 1000108001), + std::make_pair("VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO", 1000108002), + std::make_pair("VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO", 1000108003), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES", 1000253000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES", 1000175000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES", 1000241000), + std::make_pair("VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT", 1000241001), + std::make_pair("VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT", 1000241002), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES", 1000261000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES", 1000207000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES", 1000207001), + std::make_pair("VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO", 1000207002), + std::make_pair("VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO", 1000207003), + std::make_pair("VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO", 1000207004), + std::make_pair("VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO", 1000207005), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES", 1000257000), + std::make_pair("VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO", 1000244001), + std::make_pair("VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO", 1000257002), + std::make_pair("VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO", 1000257003), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO", 1000257004), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES", 1000298000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES", 1000298001), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO", 1000298002), + std::make_pair("VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO", 1000298003), + std::make_pair("VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_CONSUMPTION", 1000298004), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE", 1000298005), + std::make_pair("VK_STRUCTURE_TYPE_FAULT_DATA", 1000298007), + std::make_pair("VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO", 1000298008), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO", 1000298010), + std::make_pair("VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR", 1000001000), + std::make_pair("VK_STRUCTURE_TYPE_PRESENT_INFO_KHR", 1000001001), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR", 1000060007), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR", 1000060008), + std::make_pair("VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR", 1000060009), + std::make_pair("VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR", 1000060010), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR", 1000060011), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR", 1000060012), + std::make_pair("VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR", 1000002000), + std::make_pair("VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR", 1000002001), + std::make_pair("VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR", 1000003000), + std::make_pair("VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR", 1000004000), + std::make_pair("VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR", 1000005000), + std::make_pair("VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR", 1000006000), + std::make_pair("VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR", 1000008000), + std::make_pair("VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR", 1000009000), + std::make_pair("VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID", 1000010000), + std::make_pair("VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID", 1000010001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID", 1000010002), + std::make_pair("VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT", 1000011000), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD", 1000018000), + std::make_pair("VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT", 1000022000), + std::make_pair("VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT", 1000022001), + std::make_pair("VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT", 1000022002), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR", 1000023000), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR", 1000023001), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR", 1000023002), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR", 1000023003), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR", 1000023004), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR", 1000023005), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR", 1000023006), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR", 1000023007), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR", 1000023008), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR", 1000023009), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR", 1000023010), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR", 1000023011), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR", 1000023012), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR", 1000023013), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR", 1000023014), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR", 1000023015), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR", 1000024000), + std::make_pair("VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV", 1000026000), + std::make_pair("VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV", 1000026001), + std::make_pair("VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV", 1000026002), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT", 1000028000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT", 1000028001), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT", 1000028002), + std::make_pair("VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX", 1000029000), + std::make_pair("VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX", 1000029001), + std::make_pair("VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX", 1000029002), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX", 1000030000), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX", 1000030001), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT", 1000038000), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT", 1000038001), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT", 1000038002), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT", 1000038003), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT", 1000038004), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT", 1000038005), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT", 1000038006), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT", 1000038007), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT", 1000038008), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT", 1000038009), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT", 1000038010), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT", 1000039000), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT", 1000039001), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT", 1000039002), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT", 1000039003), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT", 1000039004), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT", 1000039005), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_EXT", 1000039006), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT", 1000039007), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT", 1000039008), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT", 1000039009), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT", 1000039010), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT", 1000039011), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT", 1000040000), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT", 1000040001), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT", 1000040002), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT", 1000040003), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT", 1000040004), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT", 1000040005), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT", 1000040006), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT", 1000040007), + std::make_pair("VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD", 1000041000), + std::make_pair("VK_STRUCTURE_TYPE_RENDERING_INFO_KHR", 1000044000), + std::make_pair("VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR", 1000044001), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR", 1000044002), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR", 1000044003), + std::make_pair("VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR", 1000044004), + std::make_pair("VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR", 1000044006), + std::make_pair("VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT", 1000044007), + std::make_pair("VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD", 1000044008), + std::make_pair("VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX", 1000044009), + std::make_pair("VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP", 1000049000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV", 1000050000), + std::make_pair("VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV", 1000056000), + std::make_pair("VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV", 1000056001), + std::make_pair("VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV", 1000057000), + std::make_pair("VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV", 1000057001), + std::make_pair("VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV", 1000058000), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR", 1000060007), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR", 1000060008), + std::make_pair("VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR", 1000060009), + std::make_pair("VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR", 1000060010), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR", 1000060011), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR", 1000060012), + std::make_pair("VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT", 1000061000), + std::make_pair("VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN", 1000062000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT", 1000066000), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT", 1000067000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT", 1000067001), + std::make_pair("VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR", 1000073000), + std::make_pair("VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR", 1000073001), + std::make_pair("VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR", 1000073002), + std::make_pair("VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR", 1000073003), + std::make_pair("VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR", 1000074000), + std::make_pair("VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR", 1000074001), + std::make_pair("VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR", 1000074002), + std::make_pair("VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR", 1000075000), + std::make_pair("VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR", 1000078000), + std::make_pair("VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR", 1000078001), + std::make_pair("VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR", 1000078002), + std::make_pair("VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR", 1000078003), + std::make_pair("VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR", 1000079000), + std::make_pair("VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR", 1000079001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR", 1000080000), + std::make_pair("VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT", 1000081000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT", 1000081001), + std::make_pair("VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT", 1000081002), + std::make_pair("VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR", 1000084000), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV", 1000087000), + std::make_pair("VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT", 1000090000), + std::make_pair("VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT", 1000091000), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT", 1000091001), + std::make_pair("VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT", 1000091002), + std::make_pair("VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT", 1000091003), + std::make_pair("VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE", 1000092000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX", 1000097000), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV", 1000098000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT", 1000099000), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT", 1000099001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT", 1000101000), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT", 1000101001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT", 1000102000), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT", 1000102001), + std::make_pair("VK_STRUCTURE_TYPE_HDR_METADATA_EXT", 1000105000), + std::make_pair("VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR", 1000111000), + std::make_pair("VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR", 1000114000), + std::make_pair("VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR", 1000114001), + std::make_pair("VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR", 1000114002), + std::make_pair("VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR", 1000115000), + std::make_pair("VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR", 1000115001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR", 1000116000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR", 1000116001), + std::make_pair("VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR", 1000116002), + std::make_pair("VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR", 1000116003), + std::make_pair("VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR", 1000116004), + std::make_pair("VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR", 1000116005), + std::make_pair("VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR", 1000116006), + std::make_pair("VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR", 1000116007), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR", 1000119000), + std::make_pair("VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR", 1000119001), + std::make_pair("VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR", 1000119002), + std::make_pair("VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR", 1000121000), + std::make_pair("VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR", 1000121001), + std::make_pair("VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR", 1000121002), + std::make_pair("VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR", 1000121003), + std::make_pair("VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR", 1000121004), + std::make_pair("VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK", 1000122000), + std::make_pair("VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK", 1000123000), + std::make_pair("VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT", 1000128000), + std::make_pair("VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT", 1000128001), + std::make_pair("VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT", 1000128002), + std::make_pair("VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT", 1000128003), + std::make_pair("VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT", 1000128004), + std::make_pair("VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID", 1000129000), + std::make_pair("VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID", 1000129001), + std::make_pair("VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID", 1000129002), + std::make_pair("VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID", 1000129003), + std::make_pair("VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID", 1000129004), + std::make_pair("VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID", 1000129005), + std::make_pair("VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID", 1000129006), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT", 1000138000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT", 1000138001), + std::make_pair("VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT", 1000138002), + std::make_pair("VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT", 1000138003), + std::make_pair("VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT", 1000143000), + std::make_pair("VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT", 1000143001), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT", 1000143002), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT", 1000143003), + std::make_pair("VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT", 1000143004), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT", 1000148000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT", 1000148001), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT", 1000148002), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV", 1000149000), + std::make_pair("VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR", 1000150007), + std::make_pair("VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR", 1000150000), + std::make_pair("VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR", 1000150002), + std::make_pair("VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR", 1000150003), + std::make_pair("VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR", 1000150004), + std::make_pair("VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR", 1000150005), + std::make_pair("VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR", 1000150006), + std::make_pair("VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR", 1000150009), + std::make_pair("VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR", 1000150010), + std::make_pair("VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR", 1000150011), + std::make_pair("VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR", 1000150012), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR", 1000150013), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR", 1000150014), + std::make_pair("VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR", 1000150017), + std::make_pair("VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR", 1000150020), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR", 1000347000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR", 1000347001), + std::make_pair("VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR", 1000150015), + std::make_pair("VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR", 1000150016), + std::make_pair("VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR", 1000150018), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR", 1000348013), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV", 1000152000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV", 1000154000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV", 1000154001), + std::make_pair("VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT", 1000158000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT", 1000158002), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT", 1000158003), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT", 1000158004), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT", 1000158005), + std::make_pair("VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT", 1000158006), + std::make_pair("VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT", 1000160000), + std::make_pair("VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT", 1000160001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR", 1000163000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR", 1000163001), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV", 1000164000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV", 1000164001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV", 1000164002), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV", 1000164005), + std::make_pair("VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV", 1000165000), + std::make_pair("VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV", 1000165001), + std::make_pair("VK_STRUCTURE_TYPE_GEOMETRY_NV", 1000165003), + std::make_pair("VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV", 1000165004), + std::make_pair("VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV", 1000165005), + std::make_pair("VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV", 1000165006), + std::make_pair("VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV", 1000165007), + std::make_pair("VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV", 1000165008), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV", 1000165009), + std::make_pair("VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV", 1000165011), + std::make_pair("VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV", 1000165012), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV", 1000166000), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV", 1000166001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT", 1000170000), + std::make_pair("VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT", 1000170001), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT", 1000174000), + std::make_pair("VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT", 1000178000), + std::make_pair("VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT", 1000178001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT", 1000178002), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR", 1000181000), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD", 1000183000), + std::make_pair("VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT", 1000184000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD", 1000185000), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT", 1000187000), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT", 1000187001), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT", 1000187002), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT", 1000187003), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT", 1000187004), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT", 1000187005), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT", 1000187006), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD", 1000189000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT", 1000190000), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT", 1000190001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT", 1000190002), + std::make_pair("VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP", 1000191000), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT", 1000192000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV", 1000201000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV", 1000202000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV", 1000202001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV", 1000203000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV", 1000204000), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV", 1000205000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV", 1000205002), + std::make_pair("VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV", 1000206000), + std::make_pair("VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV", 1000206001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL", 1000209000), + std::make_pair("VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL", 1000210000), + std::make_pair("VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL", 1000210001), + std::make_pair("VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL", 1000210002), + std::make_pair("VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL", 1000210003), + std::make_pair("VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL", 1000210004), + std::make_pair("VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL", 1000210005), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT", 1000212000), + std::make_pair("VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD", 1000213000), + std::make_pair("VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD", 1000213001), + std::make_pair("VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA", 1000214000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR", 1000215000), + std::make_pair("VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT", 1000217000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT", 1000218000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT", 1000218001), + std::make_pair("VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT", 1000218002), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT", 1000225000), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT", 1000225001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT", 1000225002), + std::make_pair("VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR", 1000226000), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR", 1000226001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR", 1000226002), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR", 1000226003), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR", 1000226004), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD", 1000227000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD", 1000229000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT", 1000234000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT", 1000237000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT", 1000238000), + std::make_pair("VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT", 1000238001), + std::make_pair("VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR", 1000239000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV", 1000240000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT", 1000244000), + std::make_pair("VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT", 1000244002), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT", 1000245000), + std::make_pair("VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT", 1000247000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR", 1000248000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV", 1000249000), + std::make_pair("VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV", 1000249001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV", 1000249002), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV", 1000250000), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV", 1000250001), + std::make_pair("VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV", 1000250002), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT", 1000251000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT", 1000252000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT", 1000254000), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT", 1000254001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT", 1000254002), + std::make_pair("VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT", 1000255000), + std::make_pair("VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT", 1000255002), + std::make_pair("VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT", 1000255001), + std::make_pair("VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT", 1000256000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT", 1000259000), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT", 1000259001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT", 1000259002), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT", 1000260000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT", 1000265000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT", 1000267000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR", 1000269000), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR", 1000269001), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR", 1000269002), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR", 1000269003), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR", 1000269004), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR", 1000269005), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT", 1000273000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT", 1000276000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV", 1000277000), + std::make_pair("VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV", 1000277001), + std::make_pair("VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV", 1000277002), + std::make_pair("VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV", 1000277003), + std::make_pair("VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV", 1000277004), + std::make_pair("VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV", 1000277005), + std::make_pair("VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV", 1000277006), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV", 1000277007), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV", 1000278000), + std::make_pair("VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV", 1000278001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR", 1000280000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR", 1000280001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT", 1000281000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT", 1000281001), + std::make_pair("VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM", 1000282000), + std::make_pair("VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM", 1000282001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT", 1000284000), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT", 1000284001), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT", 1000284002), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT", 1000286000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT", 1000286001), + std::make_pair("VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT", 1000287000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT", 1000287001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT", 1000287002), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR", 1000290000), + std::make_pair("VK_STRUCTURE_TYPE_PRESENT_ID_KHR", 1000294000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR", 1000294001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT", 1000295000), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT", 1000295001), + std::make_pair("VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT", 1000295002), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT", 1000297000), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR", 1000299000), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR", 1000299001), + std::make_pair("VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR", 1000299002), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV", 1000300000), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV", 1000300001), + std::make_pair("VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR", 1000308000), + std::make_pair("VK_STRUCTURE_TYPE_RESERVED_QCOM", 1000309000), + std::make_pair("VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR", 1000314000), + std::make_pair("VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR", 1000314001), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR", 1000314002), + std::make_pair("VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR", 1000314003), + std::make_pair("VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR", 1000314004), + std::make_pair("VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR", 1000314005), + std::make_pair("VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR", 1000314006), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR", 1000314007), + std::make_pair("VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV", 1000314008), + std::make_pair("VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV", 1000314009), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR", 1000323000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR", 1000325000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV", 1000326000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV", 1000326001), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV", 1000326002), + std::make_pair("VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV", 1000327000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV", 1000327001), + std::make_pair("VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV", 1000327002), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT", 1000330000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT", 1000332000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT", 1000332001), + std::make_pair("VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM", 1000333000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT", 1000335000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR", 1000336000), + std::make_pair("VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR", 1000337000), + std::make_pair("VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR", 1000337001), + std::make_pair("VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR", 1000337002), + std::make_pair("VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR", 1000337003), + std::make_pair("VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR", 1000337004), + std::make_pair("VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR", 1000337005), + std::make_pair("VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR", 1000337006), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR", 1000337007), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR", 1000337008), + std::make_pair("VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR", 1000337009), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR", 1000337010), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT", 1000340000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM", 1000342000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT", 1000344000), + std::make_pair("VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT", 1000346000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE", 1000351000), + std::make_pair("VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE", 1000351002), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT", 1000352000), + std::make_pair("VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT", 1000352001), + std::make_pair("VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT", 1000352002), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT", 1000353000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT", 1000355000), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT", 1000355001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT", 1000356000), + std::make_pair("VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR", 1000360000), + std::make_pair("VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA", 1000364000), + std::make_pair("VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA", 1000364001), + std::make_pair("VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA", 1000364002), + std::make_pair("VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA", 1000365000), + std::make_pair("VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA", 1000365001), + std::make_pair("VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA", 1000366000), + std::make_pair("VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA", 1000366001), + std::make_pair("VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA", 1000366002), + std::make_pair("VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA", 1000366003), + std::make_pair("VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA", 1000366004), + std::make_pair("VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA", 1000366005), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA", 1000366006), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA", 1000366007), + std::make_pair("VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA", 1000366008), + std::make_pair("VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA", 1000366009), + std::make_pair("VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI", 1000369000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI", 1000369001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI", 1000369002), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI", 1000370000), + std::make_pair("VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV", 1000371000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV", 1000371001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT", 1000377000), + std::make_pair("VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX", 1000378000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT", 1000381000), + std::make_pair("VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT", 1000381001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT", 1000388000), + std::make_pair("VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT", 1000388001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT", 1000391000), + std::make_pair("VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT", 1000391001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT", 1000392000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT", 1000392001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT", 1000411000), + std::make_pair("VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT", 1000411001), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT", 1000412000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR", 1000413000), + std::make_pair("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR", 1000413001), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR", 1000413002), + std::make_pair("VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR", 1000413003), + std::make_pair("VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT", 1000435000), +}; +static void parse_VkStructureType(const char* s, Json::Value& obj, VkStructureType& o) { + std::string _res = obj.asString(); + o = (VkStructureType)VkStructureType_map[std::string(_res)]; +} + +static std::map VkAccessFlagBits_map = { + std::make_pair("VK_ACCESS_INDIRECT_COMMAND_READ_BIT", 1UL << 0), + std::make_pair("VK_ACCESS_INDEX_READ_BIT", 1UL << 1), + std::make_pair("VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT", 1UL << 2), + std::make_pair("VK_ACCESS_UNIFORM_READ_BIT", 1UL << 3), + std::make_pair("VK_ACCESS_INPUT_ATTACHMENT_READ_BIT", 1UL << 4), + std::make_pair("VK_ACCESS_SHADER_READ_BIT", 1UL << 5), + std::make_pair("VK_ACCESS_SHADER_WRITE_BIT", 1UL << 6), + std::make_pair("VK_ACCESS_COLOR_ATTACHMENT_READ_BIT", 1UL << 7), + std::make_pair("VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT", 1UL << 8), + std::make_pair("VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT", 1UL << 9), + std::make_pair("VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT", 1UL << 10), + std::make_pair("VK_ACCESS_TRANSFER_READ_BIT", 1UL << 11), + std::make_pair("VK_ACCESS_TRANSFER_WRITE_BIT", 1UL << 12), + std::make_pair("VK_ACCESS_HOST_READ_BIT", 1UL << 13), + std::make_pair("VK_ACCESS_HOST_WRITE_BIT", 1UL << 14), + std::make_pair("VK_ACCESS_MEMORY_READ_BIT", 1UL << 15), + std::make_pair("VK_ACCESS_MEMORY_WRITE_BIT", 1UL << 16), + std::make_pair("VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT", 1UL << 25), + std::make_pair("VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT", 1UL << 26), + std::make_pair("VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT", 1UL << 27), + std::make_pair("VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT", 1UL << 20), + std::make_pair("VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT", 1UL << 19), + std::make_pair("VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR", 1UL << 21), + std::make_pair("VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR", 1UL << 22), + std::make_pair("VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT", 1UL << 24), + std::make_pair("VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR", 1UL << 23), + std::make_pair("VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV", 1UL << 17), + std::make_pair("VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV", 1UL << 18), + std::make_pair("VK_ACCESS_NONE_KHR", 0), +}; +static void parse_VkAccessFlagBits(const char* s, Json::Value& obj, VkAccessFlagBits& o) { + std::string _res = obj.asString(); + o = (VkAccessFlagBits)VkAccessFlagBits_map[std::string(_res)]; +} + +static std::map VkImageLayout_map = { + std::make_pair("VK_IMAGE_LAYOUT_UNDEFINED", 0), + std::make_pair("VK_IMAGE_LAYOUT_GENERAL", 1), + std::make_pair("VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL", 2), + std::make_pair("VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL", 3), + std::make_pair("VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL", 4), + std::make_pair("VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL", 5), + std::make_pair("VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL", 6), + std::make_pair("VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL", 7), + std::make_pair("VK_IMAGE_LAYOUT_PREINITIALIZED", 8), + std::make_pair("VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL", 1000117000), + std::make_pair("VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL", 1000117001), + std::make_pair("VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL", 1000241000), + std::make_pair("VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL", 1000241001), + std::make_pair("VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL", 1000241002), + std::make_pair("VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL", 1000241003), + std::make_pair("VK_IMAGE_LAYOUT_PRESENT_SRC_KHR", 1000001002), + std::make_pair("VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR", 1000024000), + std::make_pair("VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR", 1000024001), + std::make_pair("VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR", 1000024002), + std::make_pair("VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR", 1000111000), + std::make_pair("VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT", 1000218000), + std::make_pair("VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR", 1000164003), + std::make_pair("VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR", 1000299000), + std::make_pair("VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR", 1000299001), + std::make_pair("VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR", 1000299002), + std::make_pair("VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR", 1000314000), + std::make_pair("VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR", 1000314001), +}; +static void parse_VkImageLayout(const char* s, Json::Value& obj, VkImageLayout& o) { + std::string _res = obj.asString(); + o = (VkImageLayout)VkImageLayout_map[std::string(_res)]; +} + +static std::map VkImageAspectFlagBits_map = { + std::make_pair("VK_IMAGE_ASPECT_COLOR_BIT", 1UL << 0), + std::make_pair("VK_IMAGE_ASPECT_DEPTH_BIT", 1UL << 1), + std::make_pair("VK_IMAGE_ASPECT_STENCIL_BIT", 1UL << 2), + std::make_pair("VK_IMAGE_ASPECT_METADATA_BIT", 1UL << 3), + std::make_pair("VK_IMAGE_ASPECT_PLANE_0_BIT", 1UL << 4), + std::make_pair("VK_IMAGE_ASPECT_PLANE_1_BIT", 1UL << 5), + std::make_pair("VK_IMAGE_ASPECT_PLANE_2_BIT", 1UL << 6), + std::make_pair("VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT", 1UL << 7), + std::make_pair("VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT", 1UL << 8), + std::make_pair("VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT", 1UL << 9), + std::make_pair("VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT", 1UL << 10), + std::make_pair("VK_IMAGE_ASPECT_NONE_KHR", 0), +}; +static void parse_VkImageAspectFlagBits(const char* s, Json::Value& obj, VkImageAspectFlagBits& o) { + std::string _res = obj.asString(); + o = (VkImageAspectFlagBits)VkImageAspectFlagBits_map[std::string(_res)]; +} + +static std::map VkObjectType_map = { + std::make_pair("VK_OBJECT_TYPE_UNKNOWN", 0), + std::make_pair("VK_OBJECT_TYPE_INSTANCE", 1), + std::make_pair("VK_OBJECT_TYPE_PHYSICAL_DEVICE", 2), + std::make_pair("VK_OBJECT_TYPE_DEVICE", 3), + std::make_pair("VK_OBJECT_TYPE_QUEUE", 4), + std::make_pair("VK_OBJECT_TYPE_SEMAPHORE", 5), + std::make_pair("VK_OBJECT_TYPE_COMMAND_BUFFER", 6), + std::make_pair("VK_OBJECT_TYPE_FENCE", 7), + std::make_pair("VK_OBJECT_TYPE_DEVICE_MEMORY", 8), + std::make_pair("VK_OBJECT_TYPE_BUFFER", 9), + std::make_pair("VK_OBJECT_TYPE_IMAGE", 10), + std::make_pair("VK_OBJECT_TYPE_EVENT", 11), + std::make_pair("VK_OBJECT_TYPE_QUERY_POOL", 12), + std::make_pair("VK_OBJECT_TYPE_BUFFER_VIEW", 13), + std::make_pair("VK_OBJECT_TYPE_IMAGE_VIEW", 14), + std::make_pair("VK_OBJECT_TYPE_PIPELINE_CACHE", 16), + std::make_pair("VK_OBJECT_TYPE_PIPELINE_LAYOUT", 17), + std::make_pair("VK_OBJECT_TYPE_RENDER_PASS", 18), + std::make_pair("VK_OBJECT_TYPE_PIPELINE", 19), + std::make_pair("VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT", 20), + std::make_pair("VK_OBJECT_TYPE_SAMPLER", 21), + std::make_pair("VK_OBJECT_TYPE_DESCRIPTOR_POOL", 22), + std::make_pair("VK_OBJECT_TYPE_DESCRIPTOR_SET", 23), + std::make_pair("VK_OBJECT_TYPE_FRAMEBUFFER", 24), + std::make_pair("VK_OBJECT_TYPE_COMMAND_POOL", 25), + std::make_pair("VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION", 1000156000), + std::make_pair("VK_OBJECT_TYPE_SURFACE_KHR", 1000000000), + std::make_pair("VK_OBJECT_TYPE_SWAPCHAIN_KHR", 1000001000), + std::make_pair("VK_OBJECT_TYPE_DISPLAY_KHR", 1000002000), + std::make_pair("VK_OBJECT_TYPE_DISPLAY_MODE_KHR", 1000002001), + std::make_pair("VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT", 1000011000), + std::make_pair("VK_OBJECT_TYPE_VIDEO_SESSION_KHR", 1000023000), + std::make_pair("VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR", 1000023001), + std::make_pair("VK_OBJECT_TYPE_CU_MODULE_NVX", 1000029000), + std::make_pair("VK_OBJECT_TYPE_CU_FUNCTION_NVX", 1000029001), + std::make_pair("VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT", 1000128000), + std::make_pair("VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR", 1000150000), + std::make_pair("VK_OBJECT_TYPE_VALIDATION_CACHE_EXT", 1000160000), + std::make_pair("VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV", 1000165000), + std::make_pair("VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL", 1000210000), + std::make_pair("VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR", 1000268000), + std::make_pair("VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV", 1000277000), + std::make_pair("VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT", 1000295000), + std::make_pair("VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA", 1000366000), +}; +static void parse_VkObjectType(const char* s, Json::Value& obj, VkObjectType& o) { + std::string _res = obj.asString(); + o = (VkObjectType)VkObjectType_map[std::string(_res)]; +} + +static std::map VkPipelineCacheHeaderVersion_map = { + std::make_pair("VK_PIPELINE_CACHE_HEADER_VERSION_ONE", 1), + std::make_pair("VK_PIPELINE_CACHE_HEADER_VERSION_SAFETY_CRITICAL_ONE", 1000298001), +}; +static void parse_VkPipelineCacheHeaderVersion(const char* s, Json::Value& obj, VkPipelineCacheHeaderVersion& o) { + std::string _res = obj.asString(); + o = (VkPipelineCacheHeaderVersion)VkPipelineCacheHeaderVersion_map[std::string(_res)]; +} + +static std::map VkVendorId_map = { + std::make_pair("VK_VENDOR_ID_VIV", 0x10001), + std::make_pair("VK_VENDOR_ID_VSI", 0x10002), + std::make_pair("VK_VENDOR_ID_KAZAN", 0x10003), + std::make_pair("VK_VENDOR_ID_CODEPLAY", 0x10004), + std::make_pair("VK_VENDOR_ID_MESA", 0x10005), + std::make_pair("VK_VENDOR_ID_POCL", 0x10006), +}; +static void parse_VkVendorId(const char* s, Json::Value& obj, VkVendorId& o) { + std::string _res = obj.asString(); + o = (VkVendorId)VkVendorId_map[std::string(_res)]; +} + +static std::map VkSystemAllocationScope_map = { + std::make_pair("VK_SYSTEM_ALLOCATION_SCOPE_COMMAND", 0), + std::make_pair("VK_SYSTEM_ALLOCATION_SCOPE_OBJECT", 1), + std::make_pair("VK_SYSTEM_ALLOCATION_SCOPE_CACHE", 2), + std::make_pair("VK_SYSTEM_ALLOCATION_SCOPE_DEVICE", 3), + std::make_pair("VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE", 4), +}; +static void parse_VkSystemAllocationScope(const char* s, Json::Value& obj, VkSystemAllocationScope& o) { + std::string _res = obj.asString(); + o = (VkSystemAllocationScope)VkSystemAllocationScope_map[std::string(_res)]; +} + +static std::map VkInternalAllocationType_map = { + std::make_pair("VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE", 0), +}; +static void parse_VkInternalAllocationType(const char* s, Json::Value& obj, VkInternalAllocationType& o) { + std::string _res = obj.asString(); + o = (VkInternalAllocationType)VkInternalAllocationType_map[std::string(_res)]; +} + +static std::map VkFormat_map = { + std::make_pair("VK_FORMAT_UNDEFINED", 0), + std::make_pair("VK_FORMAT_R4G4_UNORM_PACK8", 1), + std::make_pair("VK_FORMAT_R4G4B4A4_UNORM_PACK16", 2), + std::make_pair("VK_FORMAT_B4G4R4A4_UNORM_PACK16", 3), + std::make_pair("VK_FORMAT_R5G6B5_UNORM_PACK16", 4), + std::make_pair("VK_FORMAT_B5G6R5_UNORM_PACK16", 5), + std::make_pair("VK_FORMAT_R5G5B5A1_UNORM_PACK16", 6), + std::make_pair("VK_FORMAT_B5G5R5A1_UNORM_PACK16", 7), + std::make_pair("VK_FORMAT_A1R5G5B5_UNORM_PACK16", 8), + std::make_pair("VK_FORMAT_R8_UNORM", 9), + std::make_pair("VK_FORMAT_R8_SNORM", 10), + std::make_pair("VK_FORMAT_R8_USCALED", 11), + std::make_pair("VK_FORMAT_R8_SSCALED", 12), + std::make_pair("VK_FORMAT_R8_UINT", 13), + std::make_pair("VK_FORMAT_R8_SINT", 14), + std::make_pair("VK_FORMAT_R8_SRGB", 15), + std::make_pair("VK_FORMAT_R8G8_UNORM", 16), + std::make_pair("VK_FORMAT_R8G8_SNORM", 17), + std::make_pair("VK_FORMAT_R8G8_USCALED", 18), + std::make_pair("VK_FORMAT_R8G8_SSCALED", 19), + std::make_pair("VK_FORMAT_R8G8_UINT", 20), + std::make_pair("VK_FORMAT_R8G8_SINT", 21), + std::make_pair("VK_FORMAT_R8G8_SRGB", 22), + std::make_pair("VK_FORMAT_R8G8B8_UNORM", 23), + std::make_pair("VK_FORMAT_R8G8B8_SNORM", 24), + std::make_pair("VK_FORMAT_R8G8B8_USCALED", 25), + std::make_pair("VK_FORMAT_R8G8B8_SSCALED", 26), + std::make_pair("VK_FORMAT_R8G8B8_UINT", 27), + std::make_pair("VK_FORMAT_R8G8B8_SINT", 28), + std::make_pair("VK_FORMAT_R8G8B8_SRGB", 29), + std::make_pair("VK_FORMAT_B8G8R8_UNORM", 30), + std::make_pair("VK_FORMAT_B8G8R8_SNORM", 31), + std::make_pair("VK_FORMAT_B8G8R8_USCALED", 32), + std::make_pair("VK_FORMAT_B8G8R8_SSCALED", 33), + std::make_pair("VK_FORMAT_B8G8R8_UINT", 34), + std::make_pair("VK_FORMAT_B8G8R8_SINT", 35), + std::make_pair("VK_FORMAT_B8G8R8_SRGB", 36), + std::make_pair("VK_FORMAT_R8G8B8A8_UNORM", 37), + std::make_pair("VK_FORMAT_R8G8B8A8_SNORM", 38), + std::make_pair("VK_FORMAT_R8G8B8A8_USCALED", 39), + std::make_pair("VK_FORMAT_R8G8B8A8_SSCALED", 40), + std::make_pair("VK_FORMAT_R8G8B8A8_UINT", 41), + std::make_pair("VK_FORMAT_R8G8B8A8_SINT", 42), + std::make_pair("VK_FORMAT_R8G8B8A8_SRGB", 43), + std::make_pair("VK_FORMAT_B8G8R8A8_UNORM", 44), + std::make_pair("VK_FORMAT_B8G8R8A8_SNORM", 45), + std::make_pair("VK_FORMAT_B8G8R8A8_USCALED", 46), + std::make_pair("VK_FORMAT_B8G8R8A8_SSCALED", 47), + std::make_pair("VK_FORMAT_B8G8R8A8_UINT", 48), + std::make_pair("VK_FORMAT_B8G8R8A8_SINT", 49), + std::make_pair("VK_FORMAT_B8G8R8A8_SRGB", 50), + std::make_pair("VK_FORMAT_A8B8G8R8_UNORM_PACK32", 51), + std::make_pair("VK_FORMAT_A8B8G8R8_SNORM_PACK32", 52), + std::make_pair("VK_FORMAT_A8B8G8R8_USCALED_PACK32", 53), + std::make_pair("VK_FORMAT_A8B8G8R8_SSCALED_PACK32", 54), + std::make_pair("VK_FORMAT_A8B8G8R8_UINT_PACK32", 55), + std::make_pair("VK_FORMAT_A8B8G8R8_SINT_PACK32", 56), + std::make_pair("VK_FORMAT_A8B8G8R8_SRGB_PACK32", 57), + std::make_pair("VK_FORMAT_A2R10G10B10_UNORM_PACK32", 58), + std::make_pair("VK_FORMAT_A2R10G10B10_SNORM_PACK32", 59), + std::make_pair("VK_FORMAT_A2R10G10B10_USCALED_PACK32", 60), + std::make_pair("VK_FORMAT_A2R10G10B10_SSCALED_PACK32", 61), + std::make_pair("VK_FORMAT_A2R10G10B10_UINT_PACK32", 62), + std::make_pair("VK_FORMAT_A2R10G10B10_SINT_PACK32", 63), + std::make_pair("VK_FORMAT_A2B10G10R10_UNORM_PACK32", 64), + std::make_pair("VK_FORMAT_A2B10G10R10_SNORM_PACK32", 65), + std::make_pair("VK_FORMAT_A2B10G10R10_USCALED_PACK32", 66), + std::make_pair("VK_FORMAT_A2B10G10R10_SSCALED_PACK32", 67), + std::make_pair("VK_FORMAT_A2B10G10R10_UINT_PACK32", 68), + std::make_pair("VK_FORMAT_A2B10G10R10_SINT_PACK32", 69), + std::make_pair("VK_FORMAT_R16_UNORM", 70), + std::make_pair("VK_FORMAT_R16_SNORM", 71), + std::make_pair("VK_FORMAT_R16_USCALED", 72), + std::make_pair("VK_FORMAT_R16_SSCALED", 73), + std::make_pair("VK_FORMAT_R16_UINT", 74), + std::make_pair("VK_FORMAT_R16_SINT", 75), + std::make_pair("VK_FORMAT_R16_SFLOAT", 76), + std::make_pair("VK_FORMAT_R16G16_UNORM", 77), + std::make_pair("VK_FORMAT_R16G16_SNORM", 78), + std::make_pair("VK_FORMAT_R16G16_USCALED", 79), + std::make_pair("VK_FORMAT_R16G16_SSCALED", 80), + std::make_pair("VK_FORMAT_R16G16_UINT", 81), + std::make_pair("VK_FORMAT_R16G16_SINT", 82), + std::make_pair("VK_FORMAT_R16G16_SFLOAT", 83), + std::make_pair("VK_FORMAT_R16G16B16_UNORM", 84), + std::make_pair("VK_FORMAT_R16G16B16_SNORM", 85), + std::make_pair("VK_FORMAT_R16G16B16_USCALED", 86), + std::make_pair("VK_FORMAT_R16G16B16_SSCALED", 87), + std::make_pair("VK_FORMAT_R16G16B16_UINT", 88), + std::make_pair("VK_FORMAT_R16G16B16_SINT", 89), + std::make_pair("VK_FORMAT_R16G16B16_SFLOAT", 90), + std::make_pair("VK_FORMAT_R16G16B16A16_UNORM", 91), + std::make_pair("VK_FORMAT_R16G16B16A16_SNORM", 92), + std::make_pair("VK_FORMAT_R16G16B16A16_USCALED", 93), + std::make_pair("VK_FORMAT_R16G16B16A16_SSCALED", 94), + std::make_pair("VK_FORMAT_R16G16B16A16_UINT", 95), + std::make_pair("VK_FORMAT_R16G16B16A16_SINT", 96), + std::make_pair("VK_FORMAT_R16G16B16A16_SFLOAT", 97), + std::make_pair("VK_FORMAT_R32_UINT", 98), + std::make_pair("VK_FORMAT_R32_SINT", 99), + std::make_pair("VK_FORMAT_R32_SFLOAT", 100), + std::make_pair("VK_FORMAT_R32G32_UINT", 101), + std::make_pair("VK_FORMAT_R32G32_SINT", 102), + std::make_pair("VK_FORMAT_R32G32_SFLOAT", 103), + std::make_pair("VK_FORMAT_R32G32B32_UINT", 104), + std::make_pair("VK_FORMAT_R32G32B32_SINT", 105), + std::make_pair("VK_FORMAT_R32G32B32_SFLOAT", 106), + std::make_pair("VK_FORMAT_R32G32B32A32_UINT", 107), + std::make_pair("VK_FORMAT_R32G32B32A32_SINT", 108), + std::make_pair("VK_FORMAT_R32G32B32A32_SFLOAT", 109), + std::make_pair("VK_FORMAT_R64_UINT", 110), + std::make_pair("VK_FORMAT_R64_SINT", 111), + std::make_pair("VK_FORMAT_R64_SFLOAT", 112), + std::make_pair("VK_FORMAT_R64G64_UINT", 113), + std::make_pair("VK_FORMAT_R64G64_SINT", 114), + std::make_pair("VK_FORMAT_R64G64_SFLOAT", 115), + std::make_pair("VK_FORMAT_R64G64B64_UINT", 116), + std::make_pair("VK_FORMAT_R64G64B64_SINT", 117), + std::make_pair("VK_FORMAT_R64G64B64_SFLOAT", 118), + std::make_pair("VK_FORMAT_R64G64B64A64_UINT", 119), + std::make_pair("VK_FORMAT_R64G64B64A64_SINT", 120), + std::make_pair("VK_FORMAT_R64G64B64A64_SFLOAT", 121), + std::make_pair("VK_FORMAT_B10G11R11_UFLOAT_PACK32", 122), + std::make_pair("VK_FORMAT_E5B9G9R9_UFLOAT_PACK32", 123), + std::make_pair("VK_FORMAT_D16_UNORM", 124), + std::make_pair("VK_FORMAT_X8_D24_UNORM_PACK32", 125), + std::make_pair("VK_FORMAT_D32_SFLOAT", 126), + std::make_pair("VK_FORMAT_S8_UINT", 127), + std::make_pair("VK_FORMAT_D16_UNORM_S8_UINT", 128), + std::make_pair("VK_FORMAT_D24_UNORM_S8_UINT", 129), + std::make_pair("VK_FORMAT_D32_SFLOAT_S8_UINT", 130), + std::make_pair("VK_FORMAT_BC1_RGB_UNORM_BLOCK", 131), + std::make_pair("VK_FORMAT_BC1_RGB_SRGB_BLOCK", 132), + std::make_pair("VK_FORMAT_BC1_RGBA_UNORM_BLOCK", 133), + std::make_pair("VK_FORMAT_BC1_RGBA_SRGB_BLOCK", 134), + std::make_pair("VK_FORMAT_BC2_UNORM_BLOCK", 135), + std::make_pair("VK_FORMAT_BC2_SRGB_BLOCK", 136), + std::make_pair("VK_FORMAT_BC3_UNORM_BLOCK", 137), + std::make_pair("VK_FORMAT_BC3_SRGB_BLOCK", 138), + std::make_pair("VK_FORMAT_BC4_UNORM_BLOCK", 139), + std::make_pair("VK_FORMAT_BC4_SNORM_BLOCK", 140), + std::make_pair("VK_FORMAT_BC5_UNORM_BLOCK", 141), + std::make_pair("VK_FORMAT_BC5_SNORM_BLOCK", 142), + std::make_pair("VK_FORMAT_BC6H_UFLOAT_BLOCK", 143), + std::make_pair("VK_FORMAT_BC6H_SFLOAT_BLOCK", 144), + std::make_pair("VK_FORMAT_BC7_UNORM_BLOCK", 145), + std::make_pair("VK_FORMAT_BC7_SRGB_BLOCK", 146), + std::make_pair("VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK", 147), + std::make_pair("VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK", 148), + std::make_pair("VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK", 149), + std::make_pair("VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK", 150), + std::make_pair("VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK", 151), + std::make_pair("VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK", 152), + std::make_pair("VK_FORMAT_EAC_R11_UNORM_BLOCK", 153), + std::make_pair("VK_FORMAT_EAC_R11_SNORM_BLOCK", 154), + std::make_pair("VK_FORMAT_EAC_R11G11_UNORM_BLOCK", 155), + std::make_pair("VK_FORMAT_EAC_R11G11_SNORM_BLOCK", 156), + std::make_pair("VK_FORMAT_ASTC_4x4_UNORM_BLOCK", 157), + std::make_pair("VK_FORMAT_ASTC_4x4_SRGB_BLOCK", 158), + std::make_pair("VK_FORMAT_ASTC_5x4_UNORM_BLOCK", 159), + std::make_pair("VK_FORMAT_ASTC_5x4_SRGB_BLOCK", 160), + std::make_pair("VK_FORMAT_ASTC_5x5_UNORM_BLOCK", 161), + std::make_pair("VK_FORMAT_ASTC_5x5_SRGB_BLOCK", 162), + std::make_pair("VK_FORMAT_ASTC_6x5_UNORM_BLOCK", 163), + std::make_pair("VK_FORMAT_ASTC_6x5_SRGB_BLOCK", 164), + std::make_pair("VK_FORMAT_ASTC_6x6_UNORM_BLOCK", 165), + std::make_pair("VK_FORMAT_ASTC_6x6_SRGB_BLOCK", 166), + std::make_pair("VK_FORMAT_ASTC_8x5_UNORM_BLOCK", 167), + std::make_pair("VK_FORMAT_ASTC_8x5_SRGB_BLOCK", 168), + std::make_pair("VK_FORMAT_ASTC_8x6_UNORM_BLOCK", 169), + std::make_pair("VK_FORMAT_ASTC_8x6_SRGB_BLOCK", 170), + std::make_pair("VK_FORMAT_ASTC_8x8_UNORM_BLOCK", 171), + std::make_pair("VK_FORMAT_ASTC_8x8_SRGB_BLOCK", 172), + std::make_pair("VK_FORMAT_ASTC_10x5_UNORM_BLOCK", 173), + std::make_pair("VK_FORMAT_ASTC_10x5_SRGB_BLOCK", 174), + std::make_pair("VK_FORMAT_ASTC_10x6_UNORM_BLOCK", 175), + std::make_pair("VK_FORMAT_ASTC_10x6_SRGB_BLOCK", 176), + std::make_pair("VK_FORMAT_ASTC_10x8_UNORM_BLOCK", 177), + std::make_pair("VK_FORMAT_ASTC_10x8_SRGB_BLOCK", 178), + std::make_pair("VK_FORMAT_ASTC_10x10_UNORM_BLOCK", 179), + std::make_pair("VK_FORMAT_ASTC_10x10_SRGB_BLOCK", 180), + std::make_pair("VK_FORMAT_ASTC_12x10_UNORM_BLOCK", 181), + std::make_pair("VK_FORMAT_ASTC_12x10_SRGB_BLOCK", 182), + std::make_pair("VK_FORMAT_ASTC_12x12_UNORM_BLOCK", 183), + std::make_pair("VK_FORMAT_ASTC_12x12_SRGB_BLOCK", 184), + std::make_pair("VK_FORMAT_G8B8G8R8_422_UNORM", 1000156000), + std::make_pair("VK_FORMAT_B8G8R8G8_422_UNORM", 1000156001), + std::make_pair("VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM", 1000156002), + std::make_pair("VK_FORMAT_G8_B8R8_2PLANE_420_UNORM", 1000156003), + std::make_pair("VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM", 1000156004), + std::make_pair("VK_FORMAT_G8_B8R8_2PLANE_422_UNORM", 1000156005), + std::make_pair("VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM", 1000156006), + std::make_pair("VK_FORMAT_R10X6_UNORM_PACK16", 1000156007), + std::make_pair("VK_FORMAT_R10X6G10X6_UNORM_2PACK16", 1000156008), + std::make_pair("VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16", 1000156009), + std::make_pair("VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16", 1000156010), + std::make_pair("VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16", 1000156011), + std::make_pair("VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16", 1000156012), + std::make_pair("VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16", 1000156013), + std::make_pair("VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16", 1000156014), + std::make_pair("VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16", 1000156015), + std::make_pair("VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16", 1000156016), + std::make_pair("VK_FORMAT_R12X4_UNORM_PACK16", 1000156017), + std::make_pair("VK_FORMAT_R12X4G12X4_UNORM_2PACK16", 1000156018), + std::make_pair("VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16", 1000156019), + std::make_pair("VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16", 1000156020), + std::make_pair("VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16", 1000156021), + std::make_pair("VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16", 1000156022), + std::make_pair("VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16", 1000156023), + std::make_pair("VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16", 1000156024), + std::make_pair("VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16", 1000156025), + std::make_pair("VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16", 1000156026), + std::make_pair("VK_FORMAT_G16B16G16R16_422_UNORM", 1000156027), + std::make_pair("VK_FORMAT_B16G16R16G16_422_UNORM", 1000156028), + std::make_pair("VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM", 1000156029), + std::make_pair("VK_FORMAT_G16_B16R16_2PLANE_420_UNORM", 1000156030), + std::make_pair("VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM", 1000156031), + std::make_pair("VK_FORMAT_G16_B16R16_2PLANE_422_UNORM", 1000156032), + std::make_pair("VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM", 1000156033), + std::make_pair("VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG", 1000054000), + std::make_pair("VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG", 1000054001), + std::make_pair("VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG", 1000054002), + std::make_pair("VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG", 1000054003), + std::make_pair("VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG", 1000054004), + std::make_pair("VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG", 1000054005), + std::make_pair("VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG", 1000054006), + std::make_pair("VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG", 1000054007), + std::make_pair("VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT", 1000066000), + std::make_pair("VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT", 1000066001), + std::make_pair("VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT", 1000066002), + std::make_pair("VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT", 1000066003), + std::make_pair("VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT", 1000066004), + std::make_pair("VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT", 1000066005), + std::make_pair("VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT", 1000066006), + std::make_pair("VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT", 1000066007), + std::make_pair("VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT", 1000066008), + std::make_pair("VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT", 1000066009), + std::make_pair("VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT", 1000066010), + std::make_pair("VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT", 1000066011), + std::make_pair("VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT", 1000066012), + std::make_pair("VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT", 1000066013), + std::make_pair("VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT", 1000288000), + std::make_pair("VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT", 1000288001), + std::make_pair("VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT", 1000288002), + std::make_pair("VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT", 1000288003), + std::make_pair("VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT", 1000288004), + std::make_pair("VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT", 1000288005), + std::make_pair("VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT", 1000288006), + std::make_pair("VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT", 1000288007), + std::make_pair("VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT", 1000288008), + std::make_pair("VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT", 1000288009), + std::make_pair("VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT", 1000288010), + std::make_pair("VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT", 1000288011), + std::make_pair("VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT", 1000288012), + std::make_pair("VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT", 1000288013), + std::make_pair("VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT", 1000288014), + std::make_pair("VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT", 1000288015), + std::make_pair("VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT", 1000288016), + std::make_pair("VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT", 1000288017), + std::make_pair("VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT", 1000288018), + std::make_pair("VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT", 1000288019), + std::make_pair("VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT", 1000288020), + std::make_pair("VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT", 1000288021), + std::make_pair("VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT", 1000288022), + std::make_pair("VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT", 1000288023), + std::make_pair("VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT", 1000288024), + std::make_pair("VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT", 1000288025), + std::make_pair("VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT", 1000288026), + std::make_pair("VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT", 1000288027), + std::make_pair("VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT", 1000288028), + std::make_pair("VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT", 1000288029), + std::make_pair("VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT", 1000330000), + std::make_pair("VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT", 1000330001), + std::make_pair("VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT", 1000330002), + std::make_pair("VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT", 1000330003), + std::make_pair("VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT", 1000340000), + std::make_pair("VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT", 1000340001), +}; +static void parse_VkFormat(const char* s, Json::Value& obj, VkFormat& o) { + std::string _res = obj.asString(); + o = (VkFormat)VkFormat_map[std::string(_res)]; +} + +static std::map VkFormatFeatureFlagBits_map = { + std::make_pair("VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT", 1UL << 0), + std::make_pair("VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT", 1UL << 1), + std::make_pair("VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT", 1UL << 2), + std::make_pair("VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT", 1UL << 3), + std::make_pair("VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT", 1UL << 4), + std::make_pair("VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT", 1UL << 5), + std::make_pair("VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT", 1UL << 6), + std::make_pair("VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT", 1UL << 7), + std::make_pair("VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT", 1UL << 8), + std::make_pair("VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT", 1UL << 9), + std::make_pair("VK_FORMAT_FEATURE_BLIT_SRC_BIT", 1UL << 10), + std::make_pair("VK_FORMAT_FEATURE_BLIT_DST_BIT", 1UL << 11), + std::make_pair("VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT", 1UL << 12), + std::make_pair("VK_FORMAT_FEATURE_TRANSFER_SRC_BIT", 1UL << 14), + std::make_pair("VK_FORMAT_FEATURE_TRANSFER_DST_BIT", 1UL << 15), + std::make_pair("VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT", 1UL << 17), + std::make_pair("VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT", 1UL << 18), + std::make_pair("VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT", 1UL << 19), + std::make_pair("VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT", 1UL << 20), + std::make_pair("VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT", 1UL << 21), + std::make_pair("VK_FORMAT_FEATURE_DISJOINT_BIT", 1UL << 22), + std::make_pair("VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT", 1UL << 23), + std::make_pair("VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT", 1UL << 16), + std::make_pair("VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG", 1UL << 13), + std::make_pair("VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR", 1UL << 25), + std::make_pair("VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR", 1UL << 26), + std::make_pair("VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR", 1UL << 29), + std::make_pair("VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT", 1UL << 24), + std::make_pair("VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR", 1UL << 30), + std::make_pair("VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR", 1UL << 27), + std::make_pair("VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR", 1UL << 28), +}; +static void parse_VkFormatFeatureFlagBits(const char* s, Json::Value& obj, VkFormatFeatureFlagBits& o) { + std::string _res = obj.asString(); + o = (VkFormatFeatureFlagBits)VkFormatFeatureFlagBits_map[std::string(_res)]; +} + +static std::map VkImageCreateFlagBits_map = { + std::make_pair("VK_IMAGE_CREATE_SPARSE_BINDING_BIT", 1UL << 0), + std::make_pair("VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT", 1UL << 1), + std::make_pair("VK_IMAGE_CREATE_SPARSE_ALIASED_BIT", 1UL << 2), + std::make_pair("VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT", 1UL << 3), + std::make_pair("VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT", 1UL << 4), + std::make_pair("VK_IMAGE_CREATE_ALIAS_BIT", 1UL << 10), + std::make_pair("VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT", 1UL << 6), + std::make_pair("VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT", 1UL << 5), + std::make_pair("VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT", 1UL << 7), + std::make_pair("VK_IMAGE_CREATE_EXTENDED_USAGE_BIT", 1UL << 8), + std::make_pair("VK_IMAGE_CREATE_PROTECTED_BIT", 1UL << 11), + std::make_pair("VK_IMAGE_CREATE_DISJOINT_BIT", 1UL << 9), + std::make_pair("VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV", 1UL << 13), + std::make_pair("VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT", 1UL << 12), + std::make_pair("VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT", 1UL << 14), + std::make_pair("VK_IMAGE_CREATE_RESERVED_16_BIT_AMD", 1UL << 16), + std::make_pair("VK_IMAGE_CREATE_RESERVED_394_BIT_EXT", 1UL << 17), + std::make_pair("VK_IMAGE_CREATE_RESERVED_426_BIT_QCOM", 1UL << 15), +}; +static void parse_VkImageCreateFlagBits(const char* s, Json::Value& obj, VkImageCreateFlagBits& o) { + std::string _res = obj.asString(); + o = (VkImageCreateFlagBits)VkImageCreateFlagBits_map[std::string(_res)]; +} + +static std::map VkSampleCountFlagBits_map = { + std::make_pair("VK_SAMPLE_COUNT_1_BIT", 1UL << 0), + std::make_pair("VK_SAMPLE_COUNT_2_BIT", 1UL << 1), + std::make_pair("VK_SAMPLE_COUNT_4_BIT", 1UL << 2), + std::make_pair("VK_SAMPLE_COUNT_8_BIT", 1UL << 3), + std::make_pair("VK_SAMPLE_COUNT_16_BIT", 1UL << 4), + std::make_pair("VK_SAMPLE_COUNT_32_BIT", 1UL << 5), + std::make_pair("VK_SAMPLE_COUNT_64_BIT", 1UL << 6), +}; +static void parse_VkSampleCountFlagBits(const char* s, Json::Value& obj, VkSampleCountFlagBits& o) { + std::string _res = obj.asString(); + o = (VkSampleCountFlagBits)VkSampleCountFlagBits_map[std::string(_res)]; +} + +static std::map VkImageTiling_map = { + std::make_pair("VK_IMAGE_TILING_OPTIMAL", 0), + std::make_pair("VK_IMAGE_TILING_LINEAR", 1), + std::make_pair("VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT", 1000158000), +}; +static void parse_VkImageTiling(const char* s, Json::Value& obj, VkImageTiling& o) { + std::string _res = obj.asString(); + o = (VkImageTiling)VkImageTiling_map[std::string(_res)]; +} + +static std::map VkImageType_map = { + std::make_pair("VK_IMAGE_TYPE_1D", 0), + std::make_pair("VK_IMAGE_TYPE_2D", 1), + std::make_pair("VK_IMAGE_TYPE_3D", 2), +}; +static void parse_VkImageType(const char* s, Json::Value& obj, VkImageType& o) { + std::string _res = obj.asString(); + o = (VkImageType)VkImageType_map[std::string(_res)]; +} + +static std::map VkImageUsageFlagBits_map = { + std::make_pair("VK_IMAGE_USAGE_TRANSFER_SRC_BIT", 1UL << 0), + std::make_pair("VK_IMAGE_USAGE_TRANSFER_DST_BIT", 1UL << 1), + std::make_pair("VK_IMAGE_USAGE_SAMPLED_BIT", 1UL << 2), + std::make_pair("VK_IMAGE_USAGE_STORAGE_BIT", 1UL << 3), + std::make_pair("VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT", 1UL << 4), + std::make_pair("VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", 1UL << 5), + std::make_pair("VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT", 1UL << 6), + std::make_pair("VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT", 1UL << 7), + std::make_pair("VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR", 1UL << 10), + std::make_pair("VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR", 1UL << 11), + std::make_pair("VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR", 1UL << 12), + std::make_pair("VK_IMAGE_USAGE_RESERVED_16_BIT_QCOM", 1UL << 16), + std::make_pair("VK_IMAGE_USAGE_RESERVED_17_BIT_QCOM", 1UL << 17), + std::make_pair("VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT", 1UL << 9), + std::make_pair("VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR", 1UL << 8), + std::make_pair("VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR", 1UL << 13), + std::make_pair("VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR", 1UL << 14), + std::make_pair("VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR", 1UL << 15), + std::make_pair("VK_IMAGE_USAGE_RESERVED_19_BIT_EXT", 1UL << 19), + std::make_pair("VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI", 1UL << 18), +}; +static void parse_VkImageUsageFlagBits(const char* s, Json::Value& obj, VkImageUsageFlagBits& o) { + std::string _res = obj.asString(); + o = (VkImageUsageFlagBits)VkImageUsageFlagBits_map[std::string(_res)]; +} + +static std::map VkMemoryHeapFlagBits_map = { + std::make_pair("VK_MEMORY_HEAP_DEVICE_LOCAL_BIT", 1UL << 0), + std::make_pair("VK_MEMORY_HEAP_MULTI_INSTANCE_BIT", 1UL << 1), + std::make_pair("VK_MEMORY_HEAP_SEU_SAFE_BIT", 1UL << 2), +}; +static void parse_VkMemoryHeapFlagBits(const char* s, Json::Value& obj, VkMemoryHeapFlagBits& o) { + std::string _res = obj.asString(); + o = (VkMemoryHeapFlagBits)VkMemoryHeapFlagBits_map[std::string(_res)]; +} + +static std::map VkMemoryPropertyFlagBits_map = { + std::make_pair("VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT", 1UL << 0), + std::make_pair("VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT", 1UL << 1), + std::make_pair("VK_MEMORY_PROPERTY_HOST_COHERENT_BIT", 1UL << 2), + std::make_pair("VK_MEMORY_PROPERTY_HOST_CACHED_BIT", 1UL << 3), + std::make_pair("VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT", 1UL << 4), + std::make_pair("VK_MEMORY_PROPERTY_PROTECTED_BIT", 1UL << 5), + std::make_pair("VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD", 1UL << 6), + std::make_pair("VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD", 1UL << 7), + std::make_pair("VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV", 1UL << 8), +}; +static void parse_VkMemoryPropertyFlagBits(const char* s, Json::Value& obj, VkMemoryPropertyFlagBits& o) { + std::string _res = obj.asString(); + o = (VkMemoryPropertyFlagBits)VkMemoryPropertyFlagBits_map[std::string(_res)]; +} + +static std::map VkPhysicalDeviceType_map = { + std::make_pair("VK_PHYSICAL_DEVICE_TYPE_OTHER", 0), + std::make_pair("VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU", 1), + std::make_pair("VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU", 2), + std::make_pair("VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU", 3), + std::make_pair("VK_PHYSICAL_DEVICE_TYPE_CPU", 4), +}; +static void parse_VkPhysicalDeviceType(const char* s, Json::Value& obj, VkPhysicalDeviceType& o) { + std::string _res = obj.asString(); + o = (VkPhysicalDeviceType)VkPhysicalDeviceType_map[std::string(_res)]; +} + +static std::map VkQueueFlagBits_map = { + std::make_pair("VK_QUEUE_GRAPHICS_BIT", 1UL << 0), + std::make_pair("VK_QUEUE_COMPUTE_BIT", 1UL << 1), + std::make_pair("VK_QUEUE_TRANSFER_BIT", 1UL << 2), + std::make_pair("VK_QUEUE_PROTECTED_BIT", 1UL << 4), + std::make_pair("VK_QUEUE_VIDEO_DECODE_BIT_KHR", 1UL << 5), + std::make_pair("VK_QUEUE_VIDEO_ENCODE_BIT_KHR", 1UL << 6), +}; +static void parse_VkQueueFlagBits(const char* s, Json::Value& obj, VkQueueFlagBits& o) { + std::string _res = obj.asString(); + o = (VkQueueFlagBits)VkQueueFlagBits_map[std::string(_res)]; +} + +#ifdef VK_VERSION_1_1 +static std::map VkDeviceQueueCreateFlagBits_map = { + std::make_pair("VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT", 1UL << 0), +}; +static void parse_VkDeviceQueueCreateFlagBits(const char* s, Json::Value& obj, VkDeviceQueueCreateFlagBits& o) { + std::string _res = obj.asString(); + o = (VkDeviceQueueCreateFlagBits)VkDeviceQueueCreateFlagBits_map[std::string(_res)]; +} +#endif + +static std::map VkPipelineStageFlagBits_map = { + std::make_pair("VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT", 1UL << 0), + std::make_pair("VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT", 1UL << 1), + std::make_pair("VK_PIPELINE_STAGE_VERTEX_INPUT_BIT", 1UL << 2), + std::make_pair("VK_PIPELINE_STAGE_VERTEX_SHADER_BIT", 1UL << 3), + std::make_pair("VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT", 1UL << 4), + std::make_pair("VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT", 1UL << 5), + std::make_pair("VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT", 1UL << 6), + std::make_pair("VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT", 1UL << 7), + std::make_pair("VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT", 1UL << 8), + std::make_pair("VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT", 1UL << 9), + std::make_pair("VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT", 1UL << 10), + std::make_pair("VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT", 1UL << 11), + std::make_pair("VK_PIPELINE_STAGE_TRANSFER_BIT", 1UL << 12), + std::make_pair("VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT", 1UL << 13), + std::make_pair("VK_PIPELINE_STAGE_HOST_BIT", 1UL << 14), + std::make_pair("VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT", 1UL << 15), + std::make_pair("VK_PIPELINE_STAGE_ALL_COMMANDS_BIT", 1UL << 16), + std::make_pair("VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT", 1UL << 24), + std::make_pair("VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT", 1UL << 18), + std::make_pair("VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR", 1UL << 25), + std::make_pair("VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR", 1UL << 21), + std::make_pair("VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV", 1UL << 19), + std::make_pair("VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV", 1UL << 20), + std::make_pair("VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT", 1UL << 23), + std::make_pair("VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR", 1UL << 22), + std::make_pair("VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV", 1UL << 17), + std::make_pair("VK_PIPELINE_STAGE_NONE_KHR", 0), +}; +static void parse_VkPipelineStageFlagBits(const char* s, Json::Value& obj, VkPipelineStageFlagBits& o) { + std::string _res = obj.asString(); + o = (VkPipelineStageFlagBits)VkPipelineStageFlagBits_map[std::string(_res)]; +} + +static std::map VkFenceCreateFlagBits_map = { + std::make_pair("VK_FENCE_CREATE_SIGNALED_BIT", 1UL << 0), +}; +static void parse_VkFenceCreateFlagBits(const char* s, Json::Value& obj, VkFenceCreateFlagBits& o) { + std::string _res = obj.asString(); + o = (VkFenceCreateFlagBits)VkFenceCreateFlagBits_map[std::string(_res)]; +} + +static std::map VkEventCreateFlagBits_map = { + std::make_pair("VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR", 1UL << 0), +}; +static void parse_VkEventCreateFlagBits(const char* s, Json::Value& obj, VkEventCreateFlagBits& o) { + std::string _res = obj.asString(); + o = (VkEventCreateFlagBits)VkEventCreateFlagBits_map[std::string(_res)]; +} + +static std::map VkQueryPipelineStatisticFlagBits_map = { + std::make_pair("VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT", 1UL << 0), + std::make_pair("VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT", 1UL << 1), + std::make_pair("VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT", 1UL << 2), + std::make_pair("VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT", 1UL << 3), + std::make_pair("VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT", 1UL << 4), + std::make_pair("VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT", 1UL << 5), + std::make_pair("VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT", 1UL << 6), + std::make_pair("VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT", 1UL << 7), + std::make_pair("VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT", 1UL << 8), + std::make_pair("VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT", 1UL << 9), + std::make_pair("VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT", 1UL << 10), +}; +static void parse_VkQueryPipelineStatisticFlagBits(const char* s, Json::Value& obj, VkQueryPipelineStatisticFlagBits& o) { + std::string _res = obj.asString(); + o = (VkQueryPipelineStatisticFlagBits)VkQueryPipelineStatisticFlagBits_map[std::string(_res)]; +} + +static std::map VkQueryType_map = { + std::make_pair("VK_QUERY_TYPE_OCCLUSION", 0), + std::make_pair("VK_QUERY_TYPE_PIPELINE_STATISTICS", 1), + std::make_pair("VK_QUERY_TYPE_TIMESTAMP", 2), + std::make_pair("VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR", 1000023000), + std::make_pair("VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT", 1000028004), + std::make_pair("VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR", 1000116000), + std::make_pair("VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR", 1000150000), + std::make_pair("VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR", 1000150001), + std::make_pair("VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV", 1000165000), + std::make_pair("VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL", 1000210000), + std::make_pair("VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR", 1000299000), +}; +static void parse_VkQueryType(const char* s, Json::Value& obj, VkQueryType& o) { + std::string _res = obj.asString(); + o = (VkQueryType)VkQueryType_map[std::string(_res)]; +} + +static std::map VkQueryResultFlagBits_map = { + std::make_pair("VK_QUERY_RESULT_64_BIT", 1UL << 0), + std::make_pair("VK_QUERY_RESULT_WAIT_BIT", 1UL << 1), + std::make_pair("VK_QUERY_RESULT_WITH_AVAILABILITY_BIT", 1UL << 2), + std::make_pair("VK_QUERY_RESULT_PARTIAL_BIT", 1UL << 3), + std::make_pair("VK_QUERY_RESULT_WITH_STATUS_BIT_KHR", 1UL << 4), +}; +static void parse_VkQueryResultFlagBits(const char* s, Json::Value& obj, VkQueryResultFlagBits& o) { + std::string _res = obj.asString(); + o = (VkQueryResultFlagBits)VkQueryResultFlagBits_map[std::string(_res)]; +} + +static std::map VkBufferCreateFlagBits_map = { + std::make_pair("VK_BUFFER_CREATE_SPARSE_BINDING_BIT", 1UL << 0), + std::make_pair("VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT", 1UL << 1), + std::make_pair("VK_BUFFER_CREATE_SPARSE_ALIASED_BIT", 1UL << 2), + std::make_pair("VK_BUFFER_CREATE_PROTECTED_BIT", 1UL << 3), + std::make_pair("VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT", 1UL << 4), + std::make_pair("VK_BUFFER_CREATE_RESERVED_5_BIT_AMD", 1UL << 5), +}; +static void parse_VkBufferCreateFlagBits(const char* s, Json::Value& obj, VkBufferCreateFlagBits& o) { + std::string _res = obj.asString(); + o = (VkBufferCreateFlagBits)VkBufferCreateFlagBits_map[std::string(_res)]; +} + +static std::map VkBufferUsageFlagBits_map = { + std::make_pair("VK_BUFFER_USAGE_TRANSFER_SRC_BIT", 1UL << 0), + std::make_pair("VK_BUFFER_USAGE_TRANSFER_DST_BIT", 1UL << 1), + std::make_pair("VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT", 1UL << 2), + std::make_pair("VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT", 1UL << 3), + std::make_pair("VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT", 1UL << 4), + std::make_pair("VK_BUFFER_USAGE_STORAGE_BUFFER_BIT", 1UL << 5), + std::make_pair("VK_BUFFER_USAGE_INDEX_BUFFER_BIT", 1UL << 6), + std::make_pair("VK_BUFFER_USAGE_VERTEX_BUFFER_BIT", 1UL << 7), + std::make_pair("VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT", 1UL << 8), + std::make_pair("VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT", 1UL << 17), + std::make_pair("VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR", 1UL << 13), + std::make_pair("VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR", 1UL << 14), + std::make_pair("VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT", 1UL << 11), + std::make_pair("VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT", 1UL << 12), + std::make_pair("VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT", 1UL << 9), + std::make_pair("VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR", 1UL << 19), + std::make_pair("VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR", 1UL << 20), + std::make_pair("VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR", 1UL << 10), + std::make_pair("VK_BUFFER_USAGE_RESERVED_18_BIT_QCOM", 1UL << 18), + std::make_pair("VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR", 1UL << 15), + std::make_pair("VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR", 1UL << 16), + std::make_pair("VK_BUFFER_USAGE_RESERVED_21_BIT_AMD", 1UL << 21), + std::make_pair("VK_BUFFER_USAGE_RESERVED_22_BIT_AMD", 1UL << 22), +}; +static void parse_VkBufferUsageFlagBits(const char* s, Json::Value& obj, VkBufferUsageFlagBits& o) { + std::string _res = obj.asString(); + o = (VkBufferUsageFlagBits)VkBufferUsageFlagBits_map[std::string(_res)]; +} + +static std::map VkSharingMode_map = { + std::make_pair("VK_SHARING_MODE_EXCLUSIVE", 0), + std::make_pair("VK_SHARING_MODE_CONCURRENT", 1), +}; +static void parse_VkSharingMode(const char* s, Json::Value& obj, VkSharingMode& o) { + std::string _res = obj.asString(); + o = (VkSharingMode)VkSharingMode_map[std::string(_res)]; +} + +static std::map VkComponentSwizzle_map = { + std::make_pair("VK_COMPONENT_SWIZZLE_IDENTITY", 0), + std::make_pair("VK_COMPONENT_SWIZZLE_ZERO", 1), + std::make_pair("VK_COMPONENT_SWIZZLE_ONE", 2), + std::make_pair("VK_COMPONENT_SWIZZLE_R", 3), + std::make_pair("VK_COMPONENT_SWIZZLE_G", 4), + std::make_pair("VK_COMPONENT_SWIZZLE_B", 5), + std::make_pair("VK_COMPONENT_SWIZZLE_A", 6), +}; +static void parse_VkComponentSwizzle(const char* s, Json::Value& obj, VkComponentSwizzle& o) { + std::string _res = obj.asString(); + o = (VkComponentSwizzle)VkComponentSwizzle_map[std::string(_res)]; +} + +static std::map VkImageViewCreateFlagBits_map = { + std::make_pair("VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT", 1UL << 0), + std::make_pair("VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT", 1UL << 1), +}; +static void parse_VkImageViewCreateFlagBits(const char* s, Json::Value& obj, VkImageViewCreateFlagBits& o) { + std::string _res = obj.asString(); + o = (VkImageViewCreateFlagBits)VkImageViewCreateFlagBits_map[std::string(_res)]; +} + +static std::map VkImageViewType_map = { + std::make_pair("VK_IMAGE_VIEW_TYPE_1D", 0), + std::make_pair("VK_IMAGE_VIEW_TYPE_2D", 1), + std::make_pair("VK_IMAGE_VIEW_TYPE_3D", 2), + std::make_pair("VK_IMAGE_VIEW_TYPE_CUBE", 3), + std::make_pair("VK_IMAGE_VIEW_TYPE_1D_ARRAY", 4), + std::make_pair("VK_IMAGE_VIEW_TYPE_2D_ARRAY", 5), + std::make_pair("VK_IMAGE_VIEW_TYPE_CUBE_ARRAY", 6), +}; +static void parse_VkImageViewType(const char* s, Json::Value& obj, VkImageViewType& o) { + std::string _res = obj.asString(); + o = (VkImageViewType)VkImageViewType_map[std::string(_res)]; +} + +#ifdef VKSC_VERSION_1_0 +static std::map VkPipelineCacheCreateFlagBits_map = { + std::make_pair("VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT", 1UL << 2), + std::make_pair("VK_PIPELINE_CACHE_CREATE_RESERVED_1_BIT_EXT", 1UL << 1), + std::make_pair("VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT", 1UL << 0), +}; +static void parse_VkPipelineCacheCreateFlagBits(const char* s, Json::Value& obj, VkPipelineCacheCreateFlagBits& o) { + std::string _res = obj.asString(); + o = (VkPipelineCacheCreateFlagBits)VkPipelineCacheCreateFlagBits_map[std::string(_res)]; +} +#endif + +static std::map VkBlendFactor_map = { + std::make_pair("VK_BLEND_FACTOR_ZERO", 0), + std::make_pair("VK_BLEND_FACTOR_ONE", 1), + std::make_pair("VK_BLEND_FACTOR_SRC_COLOR", 2), + std::make_pair("VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR", 3), + std::make_pair("VK_BLEND_FACTOR_DST_COLOR", 4), + std::make_pair("VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR", 5), + std::make_pair("VK_BLEND_FACTOR_SRC_ALPHA", 6), + std::make_pair("VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA", 7), + std::make_pair("VK_BLEND_FACTOR_DST_ALPHA", 8), + std::make_pair("VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA", 9), + std::make_pair("VK_BLEND_FACTOR_CONSTANT_COLOR", 10), + std::make_pair("VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR", 11), + std::make_pair("VK_BLEND_FACTOR_CONSTANT_ALPHA", 12), + std::make_pair("VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA", 13), + std::make_pair("VK_BLEND_FACTOR_SRC_ALPHA_SATURATE", 14), + std::make_pair("VK_BLEND_FACTOR_SRC1_COLOR", 15), + std::make_pair("VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR", 16), + std::make_pair("VK_BLEND_FACTOR_SRC1_ALPHA", 17), + std::make_pair("VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA", 18), +}; +static void parse_VkBlendFactor(const char* s, Json::Value& obj, VkBlendFactor& o) { + std::string _res = obj.asString(); + o = (VkBlendFactor)VkBlendFactor_map[std::string(_res)]; +} + +static std::map VkBlendOp_map = { + std::make_pair("VK_BLEND_OP_ADD", 0), + std::make_pair("VK_BLEND_OP_SUBTRACT", 1), + std::make_pair("VK_BLEND_OP_REVERSE_SUBTRACT", 2), + std::make_pair("VK_BLEND_OP_MIN", 3), + std::make_pair("VK_BLEND_OP_MAX", 4), + std::make_pair("VK_BLEND_OP_ZERO_EXT", 1000148000), + std::make_pair("VK_BLEND_OP_SRC_EXT", 1000148001), + std::make_pair("VK_BLEND_OP_DST_EXT", 1000148002), + std::make_pair("VK_BLEND_OP_SRC_OVER_EXT", 1000148003), + std::make_pair("VK_BLEND_OP_DST_OVER_EXT", 1000148004), + std::make_pair("VK_BLEND_OP_SRC_IN_EXT", 1000148005), + std::make_pair("VK_BLEND_OP_DST_IN_EXT", 1000148006), + std::make_pair("VK_BLEND_OP_SRC_OUT_EXT", 1000148007), + std::make_pair("VK_BLEND_OP_DST_OUT_EXT", 1000148008), + std::make_pair("VK_BLEND_OP_SRC_ATOP_EXT", 1000148009), + std::make_pair("VK_BLEND_OP_DST_ATOP_EXT", 1000148010), + std::make_pair("VK_BLEND_OP_XOR_EXT", 1000148011), + std::make_pair("VK_BLEND_OP_MULTIPLY_EXT", 1000148012), + std::make_pair("VK_BLEND_OP_SCREEN_EXT", 1000148013), + std::make_pair("VK_BLEND_OP_OVERLAY_EXT", 1000148014), + std::make_pair("VK_BLEND_OP_DARKEN_EXT", 1000148015), + std::make_pair("VK_BLEND_OP_LIGHTEN_EXT", 1000148016), + std::make_pair("VK_BLEND_OP_COLORDODGE_EXT", 1000148017), + std::make_pair("VK_BLEND_OP_COLORBURN_EXT", 1000148018), + std::make_pair("VK_BLEND_OP_HARDLIGHT_EXT", 1000148019), + std::make_pair("VK_BLEND_OP_SOFTLIGHT_EXT", 1000148020), + std::make_pair("VK_BLEND_OP_DIFFERENCE_EXT", 1000148021), + std::make_pair("VK_BLEND_OP_EXCLUSION_EXT", 1000148022), + std::make_pair("VK_BLEND_OP_INVERT_EXT", 1000148023), + std::make_pair("VK_BLEND_OP_INVERT_RGB_EXT", 1000148024), + std::make_pair("VK_BLEND_OP_LINEARDODGE_EXT", 1000148025), + std::make_pair("VK_BLEND_OP_LINEARBURN_EXT", 1000148026), + std::make_pair("VK_BLEND_OP_VIVIDLIGHT_EXT", 1000148027), + std::make_pair("VK_BLEND_OP_LINEARLIGHT_EXT", 1000148028), + std::make_pair("VK_BLEND_OP_PINLIGHT_EXT", 1000148029), + std::make_pair("VK_BLEND_OP_HARDMIX_EXT", 1000148030), + std::make_pair("VK_BLEND_OP_HSL_HUE_EXT", 1000148031), + std::make_pair("VK_BLEND_OP_HSL_SATURATION_EXT", 1000148032), + std::make_pair("VK_BLEND_OP_HSL_COLOR_EXT", 1000148033), + std::make_pair("VK_BLEND_OP_HSL_LUMINOSITY_EXT", 1000148034), + std::make_pair("VK_BLEND_OP_PLUS_EXT", 1000148035), + std::make_pair("VK_BLEND_OP_PLUS_CLAMPED_EXT", 1000148036), + std::make_pair("VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT", 1000148037), + std::make_pair("VK_BLEND_OP_PLUS_DARKER_EXT", 1000148038), + std::make_pair("VK_BLEND_OP_MINUS_EXT", 1000148039), + std::make_pair("VK_BLEND_OP_MINUS_CLAMPED_EXT", 1000148040), + std::make_pair("VK_BLEND_OP_CONTRAST_EXT", 1000148041), + std::make_pair("VK_BLEND_OP_INVERT_OVG_EXT", 1000148042), + std::make_pair("VK_BLEND_OP_RED_EXT", 1000148043), + std::make_pair("VK_BLEND_OP_GREEN_EXT", 1000148044), + std::make_pair("VK_BLEND_OP_BLUE_EXT", 1000148045), +}; +static void parse_VkBlendOp(const char* s, Json::Value& obj, VkBlendOp& o) { + std::string _res = obj.asString(); + o = (VkBlendOp)VkBlendOp_map[std::string(_res)]; +} + +static std::map VkColorComponentFlagBits_map = { + std::make_pair("VK_COLOR_COMPONENT_R_BIT", 1UL << 0), + std::make_pair("VK_COLOR_COMPONENT_G_BIT", 1UL << 1), + std::make_pair("VK_COLOR_COMPONENT_B_BIT", 1UL << 2), + std::make_pair("VK_COLOR_COMPONENT_A_BIT", 1UL << 3), +}; +static void parse_VkColorComponentFlagBits(const char* s, Json::Value& obj, VkColorComponentFlagBits& o) { + std::string _res = obj.asString(); + o = (VkColorComponentFlagBits)VkColorComponentFlagBits_map[std::string(_res)]; +} + +static std::map VkCompareOp_map = { + std::make_pair("VK_COMPARE_OP_NEVER", 0), + std::make_pair("VK_COMPARE_OP_LESS", 1), + std::make_pair("VK_COMPARE_OP_EQUAL", 2), + std::make_pair("VK_COMPARE_OP_LESS_OR_EQUAL", 3), + std::make_pair("VK_COMPARE_OP_GREATER", 4), + std::make_pair("VK_COMPARE_OP_NOT_EQUAL", 5), + std::make_pair("VK_COMPARE_OP_GREATER_OR_EQUAL", 6), + std::make_pair("VK_COMPARE_OP_ALWAYS", 7), +}; +static void parse_VkCompareOp(const char* s, Json::Value& obj, VkCompareOp& o) { + std::string _res = obj.asString(); + o = (VkCompareOp)VkCompareOp_map[std::string(_res)]; +} + +static std::map VkPipelineCreateFlagBits_map = { + std::make_pair("VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT", 1UL << 0), + std::make_pair("VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT", 1UL << 3), + std::make_pair("VK_PIPELINE_CREATE_DISPATCH_BASE_BIT", 1UL << 4), + std::make_pair("VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR", 1UL << 21), + std::make_pair("VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT", 1UL << 22), + std::make_pair("VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR", 1UL << 14), + std::make_pair("VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR", 1UL << 15), + std::make_pair("VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR", 1UL << 16), + std::make_pair("VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR", 1UL << 17), + std::make_pair("VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR", 1UL << 12), + std::make_pair("VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR", 1UL << 13), + std::make_pair("VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR", 1UL << 19), + std::make_pair("VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV", 1UL << 5), + std::make_pair("VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR", 1UL << 6), + std::make_pair("VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR", 1UL << 7), + std::make_pair("VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV", 1UL << 18), + std::make_pair("VK_PIPELINE_CREATE_LIBRARY_BIT_KHR", 1UL << 11), + std::make_pair("VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT", 1UL << 8), + std::make_pair("VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT", 1UL << 9), + std::make_pair("VK_PIPELINE_CREATE_RESERVED_23_BIT_AMD", 1UL << 23), + std::make_pair("VK_PIPELINE_CREATE_RESERVED_10_BIT_AMD", 1UL << 10), + std::make_pair("VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV", 1UL << 20), +}; +static void parse_VkPipelineCreateFlagBits(const char* s, Json::Value& obj, VkPipelineCreateFlagBits& o) { + std::string _res = obj.asString(); + o = (VkPipelineCreateFlagBits)VkPipelineCreateFlagBits_map[std::string(_res)]; +} + +static std::map VkPipelineShaderStageCreateFlagBits_map = { + std::make_pair("VK_PIPELINE_SHADER_STAGE_CREATE_RESERVED_2_BIT_NV", 1UL << 2), + std::make_pair("VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT", 1UL << 0), + std::make_pair("VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT", 1UL << 1), + std::make_pair("VK_PIPELINE_SHADER_STAGE_CREATE_RESERVED_3_BIT_KHR", 1UL << 3), +}; +static void parse_VkPipelineShaderStageCreateFlagBits(const char* s, Json::Value& obj, VkPipelineShaderStageCreateFlagBits& o) { + std::string _res = obj.asString(); + o = (VkPipelineShaderStageCreateFlagBits)VkPipelineShaderStageCreateFlagBits_map[std::string(_res)]; +} + +static std::map VkShaderStageFlagBits_map = { + std::make_pair("VK_SHADER_STAGE_VERTEX_BIT", 1UL << 0), + std::make_pair("VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", 1UL << 1), + std::make_pair("VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", 1UL << 2), + std::make_pair("VK_SHADER_STAGE_GEOMETRY_BIT", 1UL << 3), + std::make_pair("VK_SHADER_STAGE_FRAGMENT_BIT", 1UL << 4), + std::make_pair("VK_SHADER_STAGE_COMPUTE_BIT", 1UL << 5), + std::make_pair("VK_SHADER_STAGE_ALL_GRAPHICS", 0x0000001F), + std::make_pair("VK_SHADER_STAGE_ALL", 0x7FFFFFFF), + std::make_pair("VK_SHADER_STAGE_RAYGEN_BIT_KHR", 1UL << 8), + std::make_pair("VK_SHADER_STAGE_ANY_HIT_BIT_KHR", 1UL << 9), + std::make_pair("VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR", 1UL << 10), + std::make_pair("VK_SHADER_STAGE_MISS_BIT_KHR", 1UL << 11), + std::make_pair("VK_SHADER_STAGE_INTERSECTION_BIT_KHR", 1UL << 12), + std::make_pair("VK_SHADER_STAGE_CALLABLE_BIT_KHR", 1UL << 13), + std::make_pair("VK_SHADER_STAGE_TASK_BIT_NV", 1UL << 6), + std::make_pair("VK_SHADER_STAGE_MESH_BIT_NV", 1UL << 7), + std::make_pair("VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI", 1UL << 14), +}; +static void parse_VkShaderStageFlagBits(const char* s, Json::Value& obj, VkShaderStageFlagBits& o) { + std::string _res = obj.asString(); + o = (VkShaderStageFlagBits)VkShaderStageFlagBits_map[std::string(_res)]; +} + +static std::map VkCullModeFlagBits_map = { + std::make_pair("VK_CULL_MODE_NONE", 0), + std::make_pair("VK_CULL_MODE_FRONT_BIT", 1UL << 0), + std::make_pair("VK_CULL_MODE_BACK_BIT", 1UL << 1), + std::make_pair("VK_CULL_MODE_FRONT_AND_BACK", 0x00000003), +}; +static void parse_VkCullModeFlagBits(const char* s, Json::Value& obj, VkCullModeFlagBits& o) { + std::string _res = obj.asString(); + o = (VkCullModeFlagBits)VkCullModeFlagBits_map[std::string(_res)]; +} + +static std::map VkDynamicState_map = { + std::make_pair("VK_DYNAMIC_STATE_VIEWPORT", 0), + std::make_pair("VK_DYNAMIC_STATE_SCISSOR", 1), + std::make_pair("VK_DYNAMIC_STATE_LINE_WIDTH", 2), + std::make_pair("VK_DYNAMIC_STATE_DEPTH_BIAS", 3), + std::make_pair("VK_DYNAMIC_STATE_BLEND_CONSTANTS", 4), + std::make_pair("VK_DYNAMIC_STATE_DEPTH_BOUNDS", 5), + std::make_pair("VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK", 6), + std::make_pair("VK_DYNAMIC_STATE_STENCIL_WRITE_MASK", 7), + std::make_pair("VK_DYNAMIC_STATE_STENCIL_REFERENCE", 8), + std::make_pair("VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV", 1000087000), + std::make_pair("VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT", 1000099000), + std::make_pair("VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT", 1000143000), + std::make_pair("VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR", 1000347000), + std::make_pair("VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV", 1000164004), + std::make_pair("VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV", 1000164006), + std::make_pair("VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV", 1000205001), + std::make_pair("VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR", 1000226000), + std::make_pair("VK_DYNAMIC_STATE_LINE_STIPPLE_EXT", 1000259000), + std::make_pair("VK_DYNAMIC_STATE_CULL_MODE_EXT", 1000267000), + std::make_pair("VK_DYNAMIC_STATE_FRONT_FACE_EXT", 1000267001), + std::make_pair("VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT", 1000267002), + std::make_pair("VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT", 1000267003), + std::make_pair("VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT", 1000267004), + std::make_pair("VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT", 1000267005), + std::make_pair("VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT", 1000267006), + std::make_pair("VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT", 1000267007), + std::make_pair("VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT", 1000267008), + std::make_pair("VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT", 1000267009), + std::make_pair("VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT", 1000267010), + std::make_pair("VK_DYNAMIC_STATE_STENCIL_OP_EXT", 1000267011), + std::make_pair("VK_DYNAMIC_STATE_VERTEX_INPUT_EXT", 1000352000), + std::make_pair("VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT", 1000377000), + std::make_pair("VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT", 1000377001), + std::make_pair("VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT", 1000377002), + std::make_pair("VK_DYNAMIC_STATE_LOGIC_OP_EXT", 1000377003), + std::make_pair("VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT", 1000377004), + std::make_pair("VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT", 1000381000), +}; +static void parse_VkDynamicState(const char* s, Json::Value& obj, VkDynamicState& o) { + std::string _res = obj.asString(); + o = (VkDynamicState)VkDynamicState_map[std::string(_res)]; +} + +static std::map VkFrontFace_map = { + std::make_pair("VK_FRONT_FACE_COUNTER_CLOCKWISE", 0), + std::make_pair("VK_FRONT_FACE_CLOCKWISE", 1), +}; +static void parse_VkFrontFace(const char* s, Json::Value& obj, VkFrontFace& o) { + std::string _res = obj.asString(); + o = (VkFrontFace)VkFrontFace_map[std::string(_res)]; +} + +static std::map VkVertexInputRate_map = { + std::make_pair("VK_VERTEX_INPUT_RATE_VERTEX", 0), + std::make_pair("VK_VERTEX_INPUT_RATE_INSTANCE", 1), +}; +static void parse_VkVertexInputRate(const char* s, Json::Value& obj, VkVertexInputRate& o) { + std::string _res = obj.asString(); + o = (VkVertexInputRate)VkVertexInputRate_map[std::string(_res)]; +} + +static std::map VkPrimitiveTopology_map = { + std::make_pair("VK_PRIMITIVE_TOPOLOGY_POINT_LIST", 0), + std::make_pair("VK_PRIMITIVE_TOPOLOGY_LINE_LIST", 1), + std::make_pair("VK_PRIMITIVE_TOPOLOGY_LINE_STRIP", 2), + std::make_pair("VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST", 3), + std::make_pair("VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP", 4), + std::make_pair("VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN", 5), + std::make_pair("VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY", 6), + std::make_pair("VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY", 7), + std::make_pair("VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY", 8), + std::make_pair("VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY", 9), + std::make_pair("VK_PRIMITIVE_TOPOLOGY_PATCH_LIST", 10), +}; +static void parse_VkPrimitiveTopology(const char* s, Json::Value& obj, VkPrimitiveTopology& o) { + std::string _res = obj.asString(); + o = (VkPrimitiveTopology)VkPrimitiveTopology_map[std::string(_res)]; +} + +static std::map VkPolygonMode_map = { + std::make_pair("VK_POLYGON_MODE_FILL", 0), + std::make_pair("VK_POLYGON_MODE_LINE", 1), + std::make_pair("VK_POLYGON_MODE_POINT", 2), + std::make_pair("VK_POLYGON_MODE_FILL_RECTANGLE_NV", 1000153000), +}; +static void parse_VkPolygonMode(const char* s, Json::Value& obj, VkPolygonMode& o) { + std::string _res = obj.asString(); + o = (VkPolygonMode)VkPolygonMode_map[std::string(_res)]; +} + +static std::map VkStencilOp_map = { + std::make_pair("VK_STENCIL_OP_KEEP", 0), + std::make_pair("VK_STENCIL_OP_ZERO", 1), + std::make_pair("VK_STENCIL_OP_REPLACE", 2), + std::make_pair("VK_STENCIL_OP_INCREMENT_AND_CLAMP", 3), + std::make_pair("VK_STENCIL_OP_DECREMENT_AND_CLAMP", 4), + std::make_pair("VK_STENCIL_OP_INVERT", 5), + std::make_pair("VK_STENCIL_OP_INCREMENT_AND_WRAP", 6), + std::make_pair("VK_STENCIL_OP_DECREMENT_AND_WRAP", 7), +}; +static void parse_VkStencilOp(const char* s, Json::Value& obj, VkStencilOp& o) { + std::string _res = obj.asString(); + o = (VkStencilOp)VkStencilOp_map[std::string(_res)]; +} + +static std::map VkLogicOp_map = { + std::make_pair("VK_LOGIC_OP_CLEAR", 0), + std::make_pair("VK_LOGIC_OP_AND", 1), + std::make_pair("VK_LOGIC_OP_AND_REVERSE", 2), + std::make_pair("VK_LOGIC_OP_COPY", 3), + std::make_pair("VK_LOGIC_OP_AND_INVERTED", 4), + std::make_pair("VK_LOGIC_OP_NO_OP", 5), + std::make_pair("VK_LOGIC_OP_XOR", 6), + std::make_pair("VK_LOGIC_OP_OR", 7), + std::make_pair("VK_LOGIC_OP_NOR", 8), + std::make_pair("VK_LOGIC_OP_EQUIVALENT", 9), + std::make_pair("VK_LOGIC_OP_INVERT", 10), + std::make_pair("VK_LOGIC_OP_OR_REVERSE", 11), + std::make_pair("VK_LOGIC_OP_COPY_INVERTED", 12), + std::make_pair("VK_LOGIC_OP_OR_INVERTED", 13), + std::make_pair("VK_LOGIC_OP_NAND", 14), + std::make_pair("VK_LOGIC_OP_SET", 15), +}; +static void parse_VkLogicOp(const char* s, Json::Value& obj, VkLogicOp& o) { + std::string _res = obj.asString(); + o = (VkLogicOp)VkLogicOp_map[std::string(_res)]; +} + +static std::map VkBorderColor_map = { + std::make_pair("VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK", 0), + std::make_pair("VK_BORDER_COLOR_INT_TRANSPARENT_BLACK", 1), + std::make_pair("VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK", 2), + std::make_pair("VK_BORDER_COLOR_INT_OPAQUE_BLACK", 3), + std::make_pair("VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE", 4), + std::make_pair("VK_BORDER_COLOR_INT_OPAQUE_WHITE", 5), + std::make_pair("VK_BORDER_COLOR_FLOAT_CUSTOM_EXT", 1000287003), + std::make_pair("VK_BORDER_COLOR_INT_CUSTOM_EXT", 1000287004), +}; +static void parse_VkBorderColor(const char* s, Json::Value& obj, VkBorderColor& o) { + std::string _res = obj.asString(); + o = (VkBorderColor)VkBorderColor_map[std::string(_res)]; +} + +static std::map VkFilter_map = { + std::make_pair("VK_FILTER_NEAREST", 0), + std::make_pair("VK_FILTER_LINEAR", 1), + std::make_pair("VK_FILTER_CUBIC_IMG", 1000015000), +}; +static void parse_VkFilter(const char* s, Json::Value& obj, VkFilter& o) { + std::string _res = obj.asString(); + o = (VkFilter)VkFilter_map[std::string(_res)]; +} + +static std::map VkSamplerAddressMode_map = { + std::make_pair("VK_SAMPLER_ADDRESS_MODE_REPEAT", 0), + std::make_pair("VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT", 1), + std::make_pair("VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE", 2), + std::make_pair("VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER", 3), + std::make_pair("VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE", 4), + std::make_pair("VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE", 4), +}; +static void parse_VkSamplerAddressMode(const char* s, Json::Value& obj, VkSamplerAddressMode& o) { + std::string _res = obj.asString(); + o = (VkSamplerAddressMode)VkSamplerAddressMode_map[std::string(_res)]; +} + +static std::map VkSamplerCreateFlagBits_map = { + std::make_pair("VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT", 1UL << 0), + std::make_pair("VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT", 1UL << 1), + std::make_pair("VK_SAMPLER_CREATE_RESERVED_3_BIT_AMD", 1UL << 3), + std::make_pair("VK_SAMPLER_CREATE_RESERVED_2_BIT_EXT", 1UL << 2), +}; +static void parse_VkSamplerCreateFlagBits(const char* s, Json::Value& obj, VkSamplerCreateFlagBits& o) { + std::string _res = obj.asString(); + o = (VkSamplerCreateFlagBits)VkSamplerCreateFlagBits_map[std::string(_res)]; +} + +static std::map VkSamplerMipmapMode_map = { + std::make_pair("VK_SAMPLER_MIPMAP_MODE_NEAREST", 0), + std::make_pair("VK_SAMPLER_MIPMAP_MODE_LINEAR", 1), +}; +static void parse_VkSamplerMipmapMode(const char* s, Json::Value& obj, VkSamplerMipmapMode& o) { + std::string _res = obj.asString(); + o = (VkSamplerMipmapMode)VkSamplerMipmapMode_map[std::string(_res)]; +} + +static std::map VkDescriptorPoolCreateFlagBits_map = { + std::make_pair("VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT", 1UL << 0), + std::make_pair("VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT", 1UL << 1), + std::make_pair("VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE", 1UL << 2), +}; +static void parse_VkDescriptorPoolCreateFlagBits(const char* s, Json::Value& obj, VkDescriptorPoolCreateFlagBits& o) { + std::string _res = obj.asString(); + o = (VkDescriptorPoolCreateFlagBits)VkDescriptorPoolCreateFlagBits_map[std::string(_res)]; +} + +static std::map VkDescriptorType_map = { + std::make_pair("VK_DESCRIPTOR_TYPE_SAMPLER", 0), + std::make_pair("VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER", 1), + std::make_pair("VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE", 2), + std::make_pair("VK_DESCRIPTOR_TYPE_STORAGE_IMAGE", 3), + std::make_pair("VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER", 4), + std::make_pair("VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER", 5), + std::make_pair("VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER", 6), + std::make_pair("VK_DESCRIPTOR_TYPE_STORAGE_BUFFER", 7), + std::make_pair("VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC", 8), + std::make_pair("VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC", 9), + std::make_pair("VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT", 10), + std::make_pair("VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT", 1000138000), + std::make_pair("VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR", 1000150000), + std::make_pair("VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV", 1000165000), + std::make_pair("VK_DESCRIPTOR_TYPE_MUTABLE_VALVE", 1000351000), +}; +static void parse_VkDescriptorType(const char* s, Json::Value& obj, VkDescriptorType& o) { + std::string _res = obj.asString(); + o = (VkDescriptorType)VkDescriptorType_map[std::string(_res)]; +} + +static std::map VkDescriptorSetLayoutCreateFlagBits_map = { + std::make_pair("VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT", 1UL << 1), + std::make_pair("VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR", 1UL << 0), + std::make_pair("VK_DESCRIPTOR_SET_LAYOUT_CREATE_RESERVED_4_BIT_AMD", 1UL << 4), + std::make_pair("VK_DESCRIPTOR_SET_LAYOUT_CREATE_RESERVED_3_BIT_AMD", 1UL << 3), + std::make_pair("VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE", 1UL << 2), +}; +static void parse_VkDescriptorSetLayoutCreateFlagBits(const char* s, Json::Value& obj, VkDescriptorSetLayoutCreateFlagBits& o) { + std::string _res = obj.asString(); + o = (VkDescriptorSetLayoutCreateFlagBits)VkDescriptorSetLayoutCreateFlagBits_map[std::string(_res)]; +} + +static std::map VkAttachmentDescriptionFlagBits_map = { + std::make_pair("VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT", 1UL << 0), +}; +static void parse_VkAttachmentDescriptionFlagBits(const char* s, Json::Value& obj, VkAttachmentDescriptionFlagBits& o) { + std::string _res = obj.asString(); + o = (VkAttachmentDescriptionFlagBits)VkAttachmentDescriptionFlagBits_map[std::string(_res)]; +} + +static std::map VkAttachmentLoadOp_map = { + std::make_pair("VK_ATTACHMENT_LOAD_OP_LOAD", 0), + std::make_pair("VK_ATTACHMENT_LOAD_OP_CLEAR", 1), + std::make_pair("VK_ATTACHMENT_LOAD_OP_DONT_CARE", 2), + std::make_pair("VK_ATTACHMENT_LOAD_OP_NONE_EXT", 1000400000), +}; +static void parse_VkAttachmentLoadOp(const char* s, Json::Value& obj, VkAttachmentLoadOp& o) { + std::string _res = obj.asString(); + o = (VkAttachmentLoadOp)VkAttachmentLoadOp_map[std::string(_res)]; +} + +static std::map VkAttachmentStoreOp_map = { + std::make_pair("VK_ATTACHMENT_STORE_OP_STORE", 0), + std::make_pair("VK_ATTACHMENT_STORE_OP_DONT_CARE", 1), + std::make_pair("VK_ATTACHMENT_STORE_OP_NONE_KHR", 1000301000), +}; +static void parse_VkAttachmentStoreOp(const char* s, Json::Value& obj, VkAttachmentStoreOp& o) { + std::string _res = obj.asString(); + o = (VkAttachmentStoreOp)VkAttachmentStoreOp_map[std::string(_res)]; +} + +static std::map VkDependencyFlagBits_map = { + std::make_pair("VK_DEPENDENCY_BY_REGION_BIT", 1UL << 0), + std::make_pair("VK_DEPENDENCY_DEVICE_GROUP_BIT", 1UL << 2), + std::make_pair("VK_DEPENDENCY_VIEW_LOCAL_BIT", 1UL << 1), +}; +static void parse_VkDependencyFlagBits(const char* s, Json::Value& obj, VkDependencyFlagBits& o) { + std::string _res = obj.asString(); + o = (VkDependencyFlagBits)VkDependencyFlagBits_map[std::string(_res)]; +} + +static std::map VkFramebufferCreateFlagBits_map = { + std::make_pair("VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT", 1UL << 0), +}; +static void parse_VkFramebufferCreateFlagBits(const char* s, Json::Value& obj, VkFramebufferCreateFlagBits& o) { + std::string _res = obj.asString(); + o = (VkFramebufferCreateFlagBits)VkFramebufferCreateFlagBits_map[std::string(_res)]; +} + +static std::map VkPipelineBindPoint_map = { + std::make_pair("VK_PIPELINE_BIND_POINT_GRAPHICS", 0), + std::make_pair("VK_PIPELINE_BIND_POINT_COMPUTE", 1), + std::make_pair("VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR", 1000165000), + std::make_pair("VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI", 1000369003), +}; +static void parse_VkPipelineBindPoint(const char* s, Json::Value& obj, VkPipelineBindPoint& o) { + std::string _res = obj.asString(); + o = (VkPipelineBindPoint)VkPipelineBindPoint_map[std::string(_res)]; +} + +static std::map VkRenderPassCreateFlagBits_map = { + std::make_pair("VK_RENDER_PASS_CREATE_RESERVED_0_BIT_KHR", 1UL << 0), + std::make_pair("VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM", 1UL << 1), +}; +static void parse_VkRenderPassCreateFlagBits(const char* s, Json::Value& obj, VkRenderPassCreateFlagBits& o) { + std::string _res = obj.asString(); + o = (VkRenderPassCreateFlagBits)VkRenderPassCreateFlagBits_map[std::string(_res)]; +} + +static std::map VkSubpassDescriptionFlagBits_map = { + std::make_pair("VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX", 1UL << 0), + std::make_pair("VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX", 1UL << 1), + std::make_pair("VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM", 1UL << 2), + std::make_pair("VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM", 1UL << 3), + std::make_pair("VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM", 1UL << 4), + std::make_pair("VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM", 1UL << 5), + std::make_pair("VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM", 1UL << 6), +}; +static void parse_VkSubpassDescriptionFlagBits(const char* s, Json::Value& obj, VkSubpassDescriptionFlagBits& o) { + std::string _res = obj.asString(); + o = (VkSubpassDescriptionFlagBits)VkSubpassDescriptionFlagBits_map[std::string(_res)]; +} + +static std::map VkCommandPoolCreateFlagBits_map = { + std::make_pair("VK_COMMAND_POOL_CREATE_TRANSIENT_BIT", 1UL << 0), + std::make_pair("VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT", 1UL << 1), + std::make_pair("VK_COMMAND_POOL_CREATE_PROTECTED_BIT", 1UL << 2), +}; +static void parse_VkCommandPoolCreateFlagBits(const char* s, Json::Value& obj, VkCommandPoolCreateFlagBits& o) { + std::string _res = obj.asString(); + o = (VkCommandPoolCreateFlagBits)VkCommandPoolCreateFlagBits_map[std::string(_res)]; +} + +static std::map VkCommandPoolResetFlagBits_map = { + std::make_pair("VK_COMMAND_POOL_RESET_RESERVED_1_BIT_COREAVI", 1UL << 1), +}; +static void parse_VkCommandPoolResetFlagBits(const char* s, Json::Value& obj, VkCommandPoolResetFlagBits& o) { + std::string _res = obj.asString(); + o = (VkCommandPoolResetFlagBits)VkCommandPoolResetFlagBits_map[std::string(_res)]; +} + +static std::map VkCommandBufferLevel_map = { + std::make_pair("VK_COMMAND_BUFFER_LEVEL_PRIMARY", 0), + std::make_pair("VK_COMMAND_BUFFER_LEVEL_SECONDARY", 1), +}; +static void parse_VkCommandBufferLevel(const char* s, Json::Value& obj, VkCommandBufferLevel& o) { + std::string _res = obj.asString(); + o = (VkCommandBufferLevel)VkCommandBufferLevel_map[std::string(_res)]; +} + +static std::map VkCommandBufferUsageFlagBits_map = { + std::make_pair("VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT", 1UL << 0), + std::make_pair("VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT", 1UL << 1), + std::make_pair("VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT", 1UL << 2), +}; +static void parse_VkCommandBufferUsageFlagBits(const char* s, Json::Value& obj, VkCommandBufferUsageFlagBits& o) { + std::string _res = obj.asString(); + o = (VkCommandBufferUsageFlagBits)VkCommandBufferUsageFlagBits_map[std::string(_res)]; +} + +static std::map VkQueryControlFlagBits_map = { + std::make_pair("VK_QUERY_CONTROL_PRECISE_BIT", 1UL << 0), +}; +static void parse_VkQueryControlFlagBits(const char* s, Json::Value& obj, VkQueryControlFlagBits& o) { + std::string _res = obj.asString(); + o = (VkQueryControlFlagBits)VkQueryControlFlagBits_map[std::string(_res)]; +} + +static std::map VkCommandBufferResetFlagBits_map = { + std::make_pair("VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT", 1UL << 0), +}; +static void parse_VkCommandBufferResetFlagBits(const char* s, Json::Value& obj, VkCommandBufferResetFlagBits& o) { + std::string _res = obj.asString(); + o = (VkCommandBufferResetFlagBits)VkCommandBufferResetFlagBits_map[std::string(_res)]; +} + +static std::map VkIndexType_map = { + std::make_pair("VK_INDEX_TYPE_UINT16", 0), + std::make_pair("VK_INDEX_TYPE_UINT32", 1), + std::make_pair("VK_INDEX_TYPE_NONE_KHR", 1000165000), + std::make_pair("VK_INDEX_TYPE_UINT8_EXT", 1000265000), +}; +static void parse_VkIndexType(const char* s, Json::Value& obj, VkIndexType& o) { + std::string _res = obj.asString(); + o = (VkIndexType)VkIndexType_map[std::string(_res)]; +} + +static std::map VkStencilFaceFlagBits_map = { + std::make_pair("VK_STENCIL_FACE_FRONT_BIT", 1UL << 0), + std::make_pair("VK_STENCIL_FACE_BACK_BIT", 1UL << 1), + std::make_pair("VK_STENCIL_FACE_FRONT_AND_BACK", 0x00000003), +}; +static void parse_VkStencilFaceFlagBits(const char* s, Json::Value& obj, VkStencilFaceFlagBits& o) { + std::string _res = obj.asString(); + o = (VkStencilFaceFlagBits)VkStencilFaceFlagBits_map[std::string(_res)]; +} + +static std::map VkSubpassContents_map = { + std::make_pair("VK_SUBPASS_CONTENTS_INLINE", 0), + std::make_pair("VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS", 1), +}; +static void parse_VkSubpassContents(const char* s, Json::Value& obj, VkSubpassContents& o) { + std::string _res = obj.asString(); + o = (VkSubpassContents)VkSubpassContents_map[std::string(_res)]; +} + +static void parse_VkAccessFlags(const char* s, Json::Value& obj, VkAccessFlags& o) { + o = (VkAccessFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkAccessFlagBits)VkAccessFlagBits_map[it]; + } +} + +static void parse_VkImageAspectFlags(const char* s, Json::Value& obj, VkImageAspectFlags& o) { + o = (VkImageAspectFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkImageAspectFlagBits)VkImageAspectFlagBits_map[it]; + } +} + +static void parse_VkFormatFeatureFlags(const char* s, Json::Value& obj, VkFormatFeatureFlags& o) { + o = (VkFormatFeatureFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkFormatFeatureFlagBits)VkFormatFeatureFlagBits_map[it]; + } +} + +static void parse_VkImageCreateFlags(const char* s, Json::Value& obj, VkImageCreateFlags& o) { + o = (VkImageCreateFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkImageCreateFlagBits)VkImageCreateFlagBits_map[it]; + } +} + +static void parse_VkSampleCountFlags(const char* s, Json::Value& obj, VkSampleCountFlags& o) { + o = (VkSampleCountFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkSampleCountFlagBits)VkSampleCountFlagBits_map[it]; + } +} + +static void parse_VkImageUsageFlags(const char* s, Json::Value& obj, VkImageUsageFlags& o) { + o = (VkImageUsageFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkImageUsageFlagBits)VkImageUsageFlagBits_map[it]; + } +} + +static void parse_VkInstanceCreateFlags(const char* s, Json::Value& obj, VkInstanceCreateFlags& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} + +static void parse_VkMemoryHeapFlags(const char* s, Json::Value& obj, VkMemoryHeapFlags& o) { + o = (VkMemoryHeapFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkMemoryHeapFlagBits)VkMemoryHeapFlagBits_map[it]; + } +} + +static void parse_VkMemoryPropertyFlags(const char* s, Json::Value& obj, VkMemoryPropertyFlags& o) { + o = (VkMemoryPropertyFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkMemoryPropertyFlagBits)VkMemoryPropertyFlagBits_map[it]; + } +} + +static void parse_VkQueueFlags(const char* s, Json::Value& obj, VkQueueFlags& o) { + o = (VkQueueFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkQueueFlagBits)VkQueueFlagBits_map[it]; + } +} + +static void parse_VkDeviceCreateFlags(const char* s, Json::Value& obj, VkDeviceCreateFlags& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} + +#ifdef VK_VERSION_1_1 +static void parse_VkDeviceQueueCreateFlags(const char* s, Json::Value& obj, VkDeviceQueueCreateFlags& o) { + o = (VkDeviceQueueCreateFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkDeviceQueueCreateFlagBits)VkDeviceQueueCreateFlagBits_map[it]; + } +} +#endif + +static void parse_VkPipelineStageFlags(const char* s, Json::Value& obj, VkPipelineStageFlags& o) { + o = (VkPipelineStageFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkPipelineStageFlagBits)VkPipelineStageFlagBits_map[it]; + } +} + +static void parse_VkMemoryMapFlags(const char* s, Json::Value& obj, VkMemoryMapFlags& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} + +static void parse_VkFenceCreateFlags(const char* s, Json::Value& obj, VkFenceCreateFlags& o) { + o = (VkFenceCreateFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkFenceCreateFlagBits)VkFenceCreateFlagBits_map[it]; + } +} + +static void parse_VkSemaphoreCreateFlags(const char* s, Json::Value& obj, VkSemaphoreCreateFlags& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} + +static void parse_VkEventCreateFlags(const char* s, Json::Value& obj, VkEventCreateFlags& o) { + o = (VkEventCreateFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkEventCreateFlagBits)VkEventCreateFlagBits_map[it]; + } +} + +static void parse_VkQueryPipelineStatisticFlags(const char* s, Json::Value& obj, VkQueryPipelineStatisticFlags& o) { + o = (VkQueryPipelineStatisticFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkQueryPipelineStatisticFlagBits)VkQueryPipelineStatisticFlagBits_map[it]; + } +} + +static void parse_VkQueryPoolCreateFlags(const char* s, Json::Value& obj, VkQueryPoolCreateFlags& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} + +static void parse_VkQueryResultFlags(const char* s, Json::Value& obj, VkQueryResultFlags& o) { + o = (VkQueryResultFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkQueryResultFlagBits)VkQueryResultFlagBits_map[it]; + } +} + +static void parse_VkBufferCreateFlags(const char* s, Json::Value& obj, VkBufferCreateFlags& o) { + o = (VkBufferCreateFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkBufferCreateFlagBits)VkBufferCreateFlagBits_map[it]; + } +} + +static void parse_VkBufferUsageFlags(const char* s, Json::Value& obj, VkBufferUsageFlags& o) { + o = (VkBufferUsageFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkBufferUsageFlagBits)VkBufferUsageFlagBits_map[it]; + } +} + +static void parse_VkBufferViewCreateFlags(const char* s, Json::Value& obj, VkBufferViewCreateFlags& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} + +static void parse_VkImageViewCreateFlags(const char* s, Json::Value& obj, VkImageViewCreateFlags& o) { + o = (VkImageViewCreateFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkImageViewCreateFlagBits)VkImageViewCreateFlagBits_map[it]; + } +} + +#ifdef VKSC_VERSION_1_0 +static void parse_VkPipelineCacheCreateFlags(const char* s, Json::Value& obj, VkPipelineCacheCreateFlags& o) { + o = (VkPipelineCacheCreateFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkPipelineCacheCreateFlagBits)VkPipelineCacheCreateFlagBits_map[it]; + } +} +#endif + +static void parse_VkColorComponentFlags(const char* s, Json::Value& obj, VkColorComponentFlags& o) { + o = (VkColorComponentFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkColorComponentFlagBits)VkColorComponentFlagBits_map[it]; + } +} + +static void parse_VkPipelineCreateFlags(const char* s, Json::Value& obj, VkPipelineCreateFlags& o) { + o = (VkPipelineCreateFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkPipelineCreateFlagBits)VkPipelineCreateFlagBits_map[it]; + } +} + +static void parse_VkPipelineShaderStageCreateFlags(const char* s, Json::Value& obj, VkPipelineShaderStageCreateFlags& o) { + o = (VkPipelineShaderStageCreateFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkPipelineShaderStageCreateFlagBits)VkPipelineShaderStageCreateFlagBits_map[it]; + } +} + +static void parse_VkCullModeFlags(const char* s, Json::Value& obj, VkCullModeFlags& o) { + o = (VkCullModeFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkCullModeFlagBits)VkCullModeFlagBits_map[it]; + } +} + +static void parse_VkPipelineVertexInputStateCreateFlags(const char* s, Json::Value& obj, VkPipelineVertexInputStateCreateFlags& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} + +static void parse_VkPipelineInputAssemblyStateCreateFlags(const char* s, Json::Value& obj, VkPipelineInputAssemblyStateCreateFlags& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} + +static void parse_VkPipelineTessellationStateCreateFlags(const char* s, Json::Value& obj, VkPipelineTessellationStateCreateFlags& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} + +static void parse_VkPipelineViewportStateCreateFlags(const char* s, Json::Value& obj, VkPipelineViewportStateCreateFlags& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} + +static void parse_VkPipelineRasterizationStateCreateFlags(const char* s, Json::Value& obj, VkPipelineRasterizationStateCreateFlags& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} + +static void parse_VkPipelineMultisampleStateCreateFlags(const char* s, Json::Value& obj, VkPipelineMultisampleStateCreateFlags& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} + +static void parse_VkPipelineDepthStencilStateCreateFlags(const char* s, Json::Value& obj, VkPipelineDepthStencilStateCreateFlags& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} + +static void parse_VkPipelineColorBlendStateCreateFlags(const char* s, Json::Value& obj, VkPipelineColorBlendStateCreateFlags& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} + +static void parse_VkPipelineDynamicStateCreateFlags(const char* s, Json::Value& obj, VkPipelineDynamicStateCreateFlags& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} + +static void parse_VkPipelineLayoutCreateFlags(const char* s, Json::Value& obj, VkPipelineLayoutCreateFlags& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} + +static void parse_VkShaderStageFlags(const char* s, Json::Value& obj, VkShaderStageFlags& o) { + o = (VkShaderStageFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkShaderStageFlagBits)VkShaderStageFlagBits_map[it]; + } +} + +static void parse_VkSamplerCreateFlags(const char* s, Json::Value& obj, VkSamplerCreateFlags& o) { + o = (VkSamplerCreateFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkSamplerCreateFlagBits)VkSamplerCreateFlagBits_map[it]; + } +} + +static void parse_VkDescriptorPoolCreateFlags(const char* s, Json::Value& obj, VkDescriptorPoolCreateFlags& o) { + o = (VkDescriptorPoolCreateFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkDescriptorPoolCreateFlagBits)VkDescriptorPoolCreateFlagBits_map[it]; + } +} + +static void parse_VkDescriptorPoolResetFlags(const char* s, Json::Value& obj, VkDescriptorPoolResetFlags& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} + +static void parse_VkDescriptorSetLayoutCreateFlags(const char* s, Json::Value& obj, VkDescriptorSetLayoutCreateFlags& o) { + o = (VkDescriptorSetLayoutCreateFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkDescriptorSetLayoutCreateFlagBits)VkDescriptorSetLayoutCreateFlagBits_map[it]; + } +} + +static void parse_VkAttachmentDescriptionFlags(const char* s, Json::Value& obj, VkAttachmentDescriptionFlags& o) { + o = (VkAttachmentDescriptionFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkAttachmentDescriptionFlagBits)VkAttachmentDescriptionFlagBits_map[it]; + } +} + +static void parse_VkDependencyFlags(const char* s, Json::Value& obj, VkDependencyFlags& o) { + o = (VkDependencyFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkDependencyFlagBits)VkDependencyFlagBits_map[it]; + } +} + +static void parse_VkFramebufferCreateFlags(const char* s, Json::Value& obj, VkFramebufferCreateFlags& o) { + o = (VkFramebufferCreateFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkFramebufferCreateFlagBits)VkFramebufferCreateFlagBits_map[it]; + } +} + +static void parse_VkRenderPassCreateFlags(const char* s, Json::Value& obj, VkRenderPassCreateFlags& o) { + o = (VkRenderPassCreateFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkRenderPassCreateFlagBits)VkRenderPassCreateFlagBits_map[it]; + } +} + +static void parse_VkSubpassDescriptionFlags(const char* s, Json::Value& obj, VkSubpassDescriptionFlags& o) { + o = (VkSubpassDescriptionFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkSubpassDescriptionFlagBits)VkSubpassDescriptionFlagBits_map[it]; + } +} + +static void parse_VkCommandPoolCreateFlags(const char* s, Json::Value& obj, VkCommandPoolCreateFlags& o) { + o = (VkCommandPoolCreateFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkCommandPoolCreateFlagBits)VkCommandPoolCreateFlagBits_map[it]; + } +} + +static void parse_VkCommandPoolResetFlags(const char* s, Json::Value& obj, VkCommandPoolResetFlags& o) { + o = (VkCommandPoolResetFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkCommandPoolResetFlagBits)VkCommandPoolResetFlagBits_map[it]; + } +} + +static void parse_VkCommandBufferUsageFlags(const char* s, Json::Value& obj, VkCommandBufferUsageFlags& o) { + o = (VkCommandBufferUsageFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkCommandBufferUsageFlagBits)VkCommandBufferUsageFlagBits_map[it]; + } +} + +static void parse_VkQueryControlFlags(const char* s, Json::Value& obj, VkQueryControlFlags& o) { + o = (VkQueryControlFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkQueryControlFlagBits)VkQueryControlFlagBits_map[it]; + } +} + +static void parse_VkCommandBufferResetFlags(const char* s, Json::Value& obj, VkCommandBufferResetFlags& o) { + o = (VkCommandBufferResetFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkCommandBufferResetFlagBits)VkCommandBufferResetFlagBits_map[it]; + } +} + +static void parse_VkStencilFaceFlags(const char* s, Json::Value& obj, VkStencilFaceFlags& o) { + o = (VkStencilFaceFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkStencilFaceFlagBits)VkStencilFaceFlagBits_map[it]; + } +} + +static void parse_VkExtent2D(const char* s, Json::Value& obj, VkExtent2D& o) { + + parse_uint32_t("width", obj["width"], (o.width)); + + parse_uint32_t("height", obj["height"], (o.height)); + +} + +static void parse_VkExtent3D(const char* s, Json::Value& obj, VkExtent3D& o) { + + parse_uint32_t("width", obj["width"], (o.width)); + + parse_uint32_t("height", obj["height"], (o.height)); + + parse_uint32_t("depth", obj["depth"], (o.depth)); + +} + +static void parse_VkOffset2D(const char* s, Json::Value& obj, VkOffset2D& o) { + + parse_int32_t("x", obj["x"], (o.x)); + + parse_int32_t("y", obj["y"], (o.y)); + +} + +static void parse_VkOffset3D(const char* s, Json::Value& obj, VkOffset3D& o) { + + parse_int32_t("x", obj["x"], (o.x)); + + parse_int32_t("y", obj["y"], (o.y)); + + parse_int32_t("z", obj["z"], (o.z)); + +} + +static void parse_VkRect2D(const char* s, Json::Value& obj, VkRect2D& o) { + + parse_VkOffset2D("offset", obj["offset"], (o.offset)); + + parse_VkExtent2D("extent", obj["extent"], (o.extent)); + +} + +static void parse_VkBaseInStructure(const char* s, Json::Value& obj, VkBaseInStructure& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkBaseInStructure*)parsePNextChain(obj); + +} + +static void parse_VkBaseOutStructure(const char* s, Json::Value& obj, VkBaseOutStructure& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkBaseOutStructure*)parsePNextChain(obj); + +} + +static void parse_VkBufferMemoryBarrier(const char* s, Json::Value& obj, VkBufferMemoryBarrier& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkBufferMemoryBarrier*)parsePNextChain(obj); + + parse_VkAccessFlags("srcAccessMask", obj["srcAccessMask"], (o.srcAccessMask)); + + parse_VkAccessFlags("dstAccessMask", obj["dstAccessMask"], (o.dstAccessMask)); + + parse_uint32_t("srcQueueFamilyIndex", obj["srcQueueFamilyIndex"], (o.srcQueueFamilyIndex)); + + parse_uint32_t("dstQueueFamilyIndex", obj["dstQueueFamilyIndex"], (o.dstQueueFamilyIndex)); + + + parse_VkDeviceSize("offset", obj["offset"], (o.offset)); + + parse_VkDeviceSize("size", obj["size"], (o.size)); + +} + +static void parse_VkDispatchIndirectCommand(const char* s, Json::Value& obj, VkDispatchIndirectCommand& o) { + + parse_uint32_t("x", obj["x"], (o.x)); + + parse_uint32_t("y", obj["y"], (o.y)); + + parse_uint32_t("z", obj["z"], (o.z)); + +} + +static void parse_VkDrawIndexedIndirectCommand(const char* s, Json::Value& obj, VkDrawIndexedIndirectCommand& o) { + + parse_uint32_t("indexCount", obj["indexCount"], (o.indexCount)); + + parse_uint32_t("instanceCount", obj["instanceCount"], (o.instanceCount)); + + parse_uint32_t("firstIndex", obj["firstIndex"], (o.firstIndex)); + + parse_int32_t("vertexOffset", obj["vertexOffset"], (o.vertexOffset)); + + parse_uint32_t("firstInstance", obj["firstInstance"], (o.firstInstance)); + +} + +static void parse_VkDrawIndirectCommand(const char* s, Json::Value& obj, VkDrawIndirectCommand& o) { + + parse_uint32_t("vertexCount", obj["vertexCount"], (o.vertexCount)); + + parse_uint32_t("instanceCount", obj["instanceCount"], (o.instanceCount)); + + parse_uint32_t("firstVertex", obj["firstVertex"], (o.firstVertex)); + + parse_uint32_t("firstInstance", obj["firstInstance"], (o.firstInstance)); + +} + +static void parse_VkImageSubresourceRange(const char* s, Json::Value& obj, VkImageSubresourceRange& o) { + + parse_VkImageAspectFlags("aspectMask", obj["aspectMask"], (o.aspectMask)); + + parse_uint32_t("baseMipLevel", obj["baseMipLevel"], (o.baseMipLevel)); + + parse_uint32_t("levelCount", obj["levelCount"], (o.levelCount)); + + parse_uint32_t("baseArrayLayer", obj["baseArrayLayer"], (o.baseArrayLayer)); + + parse_uint32_t("layerCount", obj["layerCount"], (o.layerCount)); + +} + +static void parse_VkImageMemoryBarrier(const char* s, Json::Value& obj, VkImageMemoryBarrier& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImageMemoryBarrier*)parsePNextChain(obj); + + parse_VkAccessFlags("srcAccessMask", obj["srcAccessMask"], (o.srcAccessMask)); + + parse_VkAccessFlags("dstAccessMask", obj["dstAccessMask"], (o.dstAccessMask)); + + parse_VkImageLayout("oldLayout", obj["oldLayout"], (o.oldLayout)); + + parse_VkImageLayout("newLayout", obj["newLayout"], (o.newLayout)); + + parse_uint32_t("srcQueueFamilyIndex", obj["srcQueueFamilyIndex"], (o.srcQueueFamilyIndex)); + + parse_uint32_t("dstQueueFamilyIndex", obj["dstQueueFamilyIndex"], (o.dstQueueFamilyIndex)); + + + parse_VkImageSubresourceRange("subresourceRange", obj["subresourceRange"], (o.subresourceRange)); + +} + +static void parse_VkMemoryBarrier(const char* s, Json::Value& obj, VkMemoryBarrier& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkMemoryBarrier*)parsePNextChain(obj); + + parse_VkAccessFlags("srcAccessMask", obj["srcAccessMask"], (o.srcAccessMask)); + + parse_VkAccessFlags("dstAccessMask", obj["dstAccessMask"], (o.dstAccessMask)); + +} + +static void parse_VkPipelineCacheHeaderVersionOne(const char* s, Json::Value& obj, VkPipelineCacheHeaderVersionOne& o) { + + parse_uint32_t("headerSize", obj["headerSize"], (o.headerSize)); + + parse_VkPipelineCacheHeaderVersion("headerVersion", obj["headerVersion"], (o.headerVersion)); + + parse_uint32_t("vendorID", obj["vendorID"], (o.vendorID)); + + parse_uint32_t("deviceID", obj["deviceID"], (o.deviceID)); + + Json::Value& obj_pipelineCacheUUID_arr = obj["pipelineCacheUUID"]; + for (unsigned int i = 0; i < obj_pipelineCacheUUID_arr.size(); i++) { + parse_uint8_t("pipelineCacheUUID", obj_pipelineCacheUUID_arr[i], const_cast((o.pipelineCacheUUID[i]))); + } + +} + +static void parse_VkAllocationCallbacks(const char* s, Json::Value& obj, VkAllocationCallbacks& o) { + + /** Note: Ignoring void* data. **/ + + /** Note: Ignoring function pointer (PFN_vkAllocationFunction). **/ + + /** Note: Ignoring function pointer (PFN_vkReallocationFunction). **/ + + /** Note: Ignoring function pointer (PFN_vkFreeFunction). **/ + + /** Note: Ignoring function pointer (PFN_vkInternalAllocationNotification). **/ + + /** Note: Ignoring function pointer (PFN_vkInternalFreeNotification). **/ + +} + +static void parse_VkApplicationInfo(const char* s, Json::Value& obj, VkApplicationInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkApplicationInfo*)parsePNextChain(obj); + + /** TODO: Handle this - pApplicationName **/ + + parse_uint32_t("applicationVersion", obj["applicationVersion"], (o.applicationVersion)); + + /** TODO: Handle this - pEngineName **/ + + parse_uint32_t("engineVersion", obj["engineVersion"], (o.engineVersion)); + + parse_uint32_t("apiVersion", obj["apiVersion"], (o.apiVersion)); + +} + +static void parse_VkFormatProperties(const char* s, Json::Value& obj, VkFormatProperties& o) { + + parse_VkFormatFeatureFlags("linearTilingFeatures", obj["linearTilingFeatures"], (o.linearTilingFeatures)); + + parse_VkFormatFeatureFlags("optimalTilingFeatures", obj["optimalTilingFeatures"], (o.optimalTilingFeatures)); + + parse_VkFormatFeatureFlags("bufferFeatures", obj["bufferFeatures"], (o.bufferFeatures)); + +} + +static void parse_VkImageFormatProperties(const char* s, Json::Value& obj, VkImageFormatProperties& o) { + + parse_VkExtent3D("maxExtent", obj["maxExtent"], (o.maxExtent)); + + parse_uint32_t("maxMipLevels", obj["maxMipLevels"], (o.maxMipLevels)); + + parse_uint32_t("maxArrayLayers", obj["maxArrayLayers"], (o.maxArrayLayers)); + + parse_VkSampleCountFlags("sampleCounts", obj["sampleCounts"], (o.sampleCounts)); + + parse_VkDeviceSize("maxResourceSize", obj["maxResourceSize"], (o.maxResourceSize)); + +} + +static void parse_VkInstanceCreateInfo(const char* s, Json::Value& obj, VkInstanceCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkInstanceCreateInfo*)parsePNextChain(obj); + + parse_VkInstanceCreateFlags("flags", obj["flags"], (o.flags)); + + { + Json::Value& obj_pApplicationInfo = obj["pApplicationInfo"]; + const int sz = obj_pApplicationInfo.size(); + if (obj_pApplicationInfo.size() == 0) { + (o.pApplicationInfo) = nullptr; + } else { + (o.pApplicationInfo) = (VkApplicationInfo*)s_globalMem.allocate(1, sizeof(VkApplicationInfo)); + parse_VkApplicationInfo("pApplicationInfo", obj_pApplicationInfo, const_cast(*(o.pApplicationInfo))); + } + } + + parse_uint32_t("enabledLayerCount", obj["enabledLayerCount"], (o.enabledLayerCount)); + + /** TODO: Handle this - ppEnabledLayerNames **/ + + parse_uint32_t("enabledExtensionCount", obj["enabledExtensionCount"], (o.enabledExtensionCount)); + + /** TODO: Handle this - ppEnabledExtensionNames **/ + +} + +static void parse_VkMemoryHeap(const char* s, Json::Value& obj, VkMemoryHeap& o) { + + parse_VkDeviceSize("size", obj["size"], (o.size)); + + parse_VkMemoryHeapFlags("flags", obj["flags"], (o.flags)); + +} + +static void parse_VkMemoryType(const char* s, Json::Value& obj, VkMemoryType& o) { + + parse_VkMemoryPropertyFlags("propertyFlags", obj["propertyFlags"], (o.propertyFlags)); + + parse_uint32_t("heapIndex", obj["heapIndex"], (o.heapIndex)); + +} + +static void parse_VkPhysicalDeviceFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceFeatures& o) { + + parse_VkBool32("robustBufferAccess", obj["robustBufferAccess"], (o.robustBufferAccess)); + + parse_VkBool32("fullDrawIndexUint32", obj["fullDrawIndexUint32"], (o.fullDrawIndexUint32)); + + parse_VkBool32("imageCubeArray", obj["imageCubeArray"], (o.imageCubeArray)); + + parse_VkBool32("independentBlend", obj["independentBlend"], (o.independentBlend)); + + parse_VkBool32("geometryShader", obj["geometryShader"], (o.geometryShader)); + + parse_VkBool32("tessellationShader", obj["tessellationShader"], (o.tessellationShader)); + + parse_VkBool32("sampleRateShading", obj["sampleRateShading"], (o.sampleRateShading)); + + parse_VkBool32("dualSrcBlend", obj["dualSrcBlend"], (o.dualSrcBlend)); + + parse_VkBool32("logicOp", obj["logicOp"], (o.logicOp)); + + parse_VkBool32("multiDrawIndirect", obj["multiDrawIndirect"], (o.multiDrawIndirect)); + + parse_VkBool32("drawIndirectFirstInstance", obj["drawIndirectFirstInstance"], (o.drawIndirectFirstInstance)); + + parse_VkBool32("depthClamp", obj["depthClamp"], (o.depthClamp)); + + parse_VkBool32("depthBiasClamp", obj["depthBiasClamp"], (o.depthBiasClamp)); + + parse_VkBool32("fillModeNonSolid", obj["fillModeNonSolid"], (o.fillModeNonSolid)); + + parse_VkBool32("depthBounds", obj["depthBounds"], (o.depthBounds)); + + parse_VkBool32("wideLines", obj["wideLines"], (o.wideLines)); + + parse_VkBool32("largePoints", obj["largePoints"], (o.largePoints)); + + parse_VkBool32("alphaToOne", obj["alphaToOne"], (o.alphaToOne)); + + parse_VkBool32("multiViewport", obj["multiViewport"], (o.multiViewport)); + + parse_VkBool32("samplerAnisotropy", obj["samplerAnisotropy"], (o.samplerAnisotropy)); + + parse_VkBool32("textureCompressionETC2", obj["textureCompressionETC2"], (o.textureCompressionETC2)); + + parse_VkBool32("textureCompressionASTC_LDR", obj["textureCompressionASTC_LDR"], (o.textureCompressionASTC_LDR)); + + parse_VkBool32("textureCompressionBC", obj["textureCompressionBC"], (o.textureCompressionBC)); + + parse_VkBool32("occlusionQueryPrecise", obj["occlusionQueryPrecise"], (o.occlusionQueryPrecise)); + + parse_VkBool32("pipelineStatisticsQuery", obj["pipelineStatisticsQuery"], (o.pipelineStatisticsQuery)); + + parse_VkBool32("vertexPipelineStoresAndAtomics", obj["vertexPipelineStoresAndAtomics"], (o.vertexPipelineStoresAndAtomics)); + + parse_VkBool32("fragmentStoresAndAtomics", obj["fragmentStoresAndAtomics"], (o.fragmentStoresAndAtomics)); + + parse_VkBool32("shaderTessellationAndGeometryPointSize", obj["shaderTessellationAndGeometryPointSize"], (o.shaderTessellationAndGeometryPointSize)); + + parse_VkBool32("shaderImageGatherExtended", obj["shaderImageGatherExtended"], (o.shaderImageGatherExtended)); + + parse_VkBool32("shaderStorageImageExtendedFormats", obj["shaderStorageImageExtendedFormats"], (o.shaderStorageImageExtendedFormats)); + + parse_VkBool32("shaderStorageImageMultisample", obj["shaderStorageImageMultisample"], (o.shaderStorageImageMultisample)); + + parse_VkBool32("shaderStorageImageReadWithoutFormat", obj["shaderStorageImageReadWithoutFormat"], (o.shaderStorageImageReadWithoutFormat)); + + parse_VkBool32("shaderStorageImageWriteWithoutFormat", obj["shaderStorageImageWriteWithoutFormat"], (o.shaderStorageImageWriteWithoutFormat)); + + parse_VkBool32("shaderUniformBufferArrayDynamicIndexing", obj["shaderUniformBufferArrayDynamicIndexing"], (o.shaderUniformBufferArrayDynamicIndexing)); + + parse_VkBool32("shaderSampledImageArrayDynamicIndexing", obj["shaderSampledImageArrayDynamicIndexing"], (o.shaderSampledImageArrayDynamicIndexing)); + + parse_VkBool32("shaderStorageBufferArrayDynamicIndexing", obj["shaderStorageBufferArrayDynamicIndexing"], (o.shaderStorageBufferArrayDynamicIndexing)); + + parse_VkBool32("shaderStorageImageArrayDynamicIndexing", obj["shaderStorageImageArrayDynamicIndexing"], (o.shaderStorageImageArrayDynamicIndexing)); + + parse_VkBool32("shaderClipDistance", obj["shaderClipDistance"], (o.shaderClipDistance)); + + parse_VkBool32("shaderCullDistance", obj["shaderCullDistance"], (o.shaderCullDistance)); + + parse_VkBool32("shaderFloat64", obj["shaderFloat64"], (o.shaderFloat64)); + + parse_VkBool32("shaderInt64", obj["shaderInt64"], (o.shaderInt64)); + + parse_VkBool32("shaderInt16", obj["shaderInt16"], (o.shaderInt16)); + + parse_VkBool32("shaderResourceResidency", obj["shaderResourceResidency"], (o.shaderResourceResidency)); + + parse_VkBool32("shaderResourceMinLod", obj["shaderResourceMinLod"], (o.shaderResourceMinLod)); + + parse_VkBool32("sparseBinding", obj["sparseBinding"], (o.sparseBinding)); + + parse_VkBool32("sparseResidencyBuffer", obj["sparseResidencyBuffer"], (o.sparseResidencyBuffer)); + + parse_VkBool32("sparseResidencyImage2D", obj["sparseResidencyImage2D"], (o.sparseResidencyImage2D)); + + parse_VkBool32("sparseResidencyImage3D", obj["sparseResidencyImage3D"], (o.sparseResidencyImage3D)); + + parse_VkBool32("sparseResidency2Samples", obj["sparseResidency2Samples"], (o.sparseResidency2Samples)); + + parse_VkBool32("sparseResidency4Samples", obj["sparseResidency4Samples"], (o.sparseResidency4Samples)); + + parse_VkBool32("sparseResidency8Samples", obj["sparseResidency8Samples"], (o.sparseResidency8Samples)); + + parse_VkBool32("sparseResidency16Samples", obj["sparseResidency16Samples"], (o.sparseResidency16Samples)); + + parse_VkBool32("sparseResidencyAliased", obj["sparseResidencyAliased"], (o.sparseResidencyAliased)); + + parse_VkBool32("variableMultisampleRate", obj["variableMultisampleRate"], (o.variableMultisampleRate)); + + parse_VkBool32("inheritedQueries", obj["inheritedQueries"], (o.inheritedQueries)); + +} + +static void parse_VkPhysicalDeviceLimits(const char* s, Json::Value& obj, VkPhysicalDeviceLimits& o) { + + parse_uint32_t("maxImageDimension1D", obj["maxImageDimension1D"], (o.maxImageDimension1D)); + + parse_uint32_t("maxImageDimension2D", obj["maxImageDimension2D"], (o.maxImageDimension2D)); + + parse_uint32_t("maxImageDimension3D", obj["maxImageDimension3D"], (o.maxImageDimension3D)); + + parse_uint32_t("maxImageDimensionCube", obj["maxImageDimensionCube"], (o.maxImageDimensionCube)); + + parse_uint32_t("maxImageArrayLayers", obj["maxImageArrayLayers"], (o.maxImageArrayLayers)); + + parse_uint32_t("maxTexelBufferElements", obj["maxTexelBufferElements"], (o.maxTexelBufferElements)); + + parse_uint32_t("maxUniformBufferRange", obj["maxUniformBufferRange"], (o.maxUniformBufferRange)); + + parse_uint32_t("maxStorageBufferRange", obj["maxStorageBufferRange"], (o.maxStorageBufferRange)); + + parse_uint32_t("maxPushConstantsSize", obj["maxPushConstantsSize"], (o.maxPushConstantsSize)); + + parse_uint32_t("maxMemoryAllocationCount", obj["maxMemoryAllocationCount"], (o.maxMemoryAllocationCount)); + + parse_uint32_t("maxSamplerAllocationCount", obj["maxSamplerAllocationCount"], (o.maxSamplerAllocationCount)); + + parse_VkDeviceSize("bufferImageGranularity", obj["bufferImageGranularity"], (o.bufferImageGranularity)); + + parse_VkDeviceSize("sparseAddressSpaceSize", obj["sparseAddressSpaceSize"], (o.sparseAddressSpaceSize)); + + parse_uint32_t("maxBoundDescriptorSets", obj["maxBoundDescriptorSets"], (o.maxBoundDescriptorSets)); + + parse_uint32_t("maxPerStageDescriptorSamplers", obj["maxPerStageDescriptorSamplers"], (o.maxPerStageDescriptorSamplers)); + + parse_uint32_t("maxPerStageDescriptorUniformBuffers", obj["maxPerStageDescriptorUniformBuffers"], (o.maxPerStageDescriptorUniformBuffers)); + + parse_uint32_t("maxPerStageDescriptorStorageBuffers", obj["maxPerStageDescriptorStorageBuffers"], (o.maxPerStageDescriptorStorageBuffers)); + + parse_uint32_t("maxPerStageDescriptorSampledImages", obj["maxPerStageDescriptorSampledImages"], (o.maxPerStageDescriptorSampledImages)); + + parse_uint32_t("maxPerStageDescriptorStorageImages", obj["maxPerStageDescriptorStorageImages"], (o.maxPerStageDescriptorStorageImages)); + + parse_uint32_t("maxPerStageDescriptorInputAttachments", obj["maxPerStageDescriptorInputAttachments"], (o.maxPerStageDescriptorInputAttachments)); + + parse_uint32_t("maxPerStageResources", obj["maxPerStageResources"], (o.maxPerStageResources)); + + parse_uint32_t("maxDescriptorSetSamplers", obj["maxDescriptorSetSamplers"], (o.maxDescriptorSetSamplers)); + + parse_uint32_t("maxDescriptorSetUniformBuffers", obj["maxDescriptorSetUniformBuffers"], (o.maxDescriptorSetUniformBuffers)); + + parse_uint32_t("maxDescriptorSetUniformBuffersDynamic", obj["maxDescriptorSetUniformBuffersDynamic"], (o.maxDescriptorSetUniformBuffersDynamic)); + + parse_uint32_t("maxDescriptorSetStorageBuffers", obj["maxDescriptorSetStorageBuffers"], (o.maxDescriptorSetStorageBuffers)); + + parse_uint32_t("maxDescriptorSetStorageBuffersDynamic", obj["maxDescriptorSetStorageBuffersDynamic"], (o.maxDescriptorSetStorageBuffersDynamic)); + + parse_uint32_t("maxDescriptorSetSampledImages", obj["maxDescriptorSetSampledImages"], (o.maxDescriptorSetSampledImages)); + + parse_uint32_t("maxDescriptorSetStorageImages", obj["maxDescriptorSetStorageImages"], (o.maxDescriptorSetStorageImages)); + + parse_uint32_t("maxDescriptorSetInputAttachments", obj["maxDescriptorSetInputAttachments"], (o.maxDescriptorSetInputAttachments)); + + parse_uint32_t("maxVertexInputAttributes", obj["maxVertexInputAttributes"], (o.maxVertexInputAttributes)); + + parse_uint32_t("maxVertexInputBindings", obj["maxVertexInputBindings"], (o.maxVertexInputBindings)); + + parse_uint32_t("maxVertexInputAttributeOffset", obj["maxVertexInputAttributeOffset"], (o.maxVertexInputAttributeOffset)); + + parse_uint32_t("maxVertexInputBindingStride", obj["maxVertexInputBindingStride"], (o.maxVertexInputBindingStride)); + + parse_uint32_t("maxVertexOutputComponents", obj["maxVertexOutputComponents"], (o.maxVertexOutputComponents)); + + parse_uint32_t("maxTessellationGenerationLevel", obj["maxTessellationGenerationLevel"], (o.maxTessellationGenerationLevel)); + + parse_uint32_t("maxTessellationPatchSize", obj["maxTessellationPatchSize"], (o.maxTessellationPatchSize)); + + parse_uint32_t("maxTessellationControlPerVertexInputComponents", obj["maxTessellationControlPerVertexInputComponents"], (o.maxTessellationControlPerVertexInputComponents)); + + parse_uint32_t("maxTessellationControlPerVertexOutputComponents", obj["maxTessellationControlPerVertexOutputComponents"], (o.maxTessellationControlPerVertexOutputComponents)); + + parse_uint32_t("maxTessellationControlPerPatchOutputComponents", obj["maxTessellationControlPerPatchOutputComponents"], (o.maxTessellationControlPerPatchOutputComponents)); + + parse_uint32_t("maxTessellationControlTotalOutputComponents", obj["maxTessellationControlTotalOutputComponents"], (o.maxTessellationControlTotalOutputComponents)); + + parse_uint32_t("maxTessellationEvaluationInputComponents", obj["maxTessellationEvaluationInputComponents"], (o.maxTessellationEvaluationInputComponents)); + + parse_uint32_t("maxTessellationEvaluationOutputComponents", obj["maxTessellationEvaluationOutputComponents"], (o.maxTessellationEvaluationOutputComponents)); + + parse_uint32_t("maxGeometryShaderInvocations", obj["maxGeometryShaderInvocations"], (o.maxGeometryShaderInvocations)); + + parse_uint32_t("maxGeometryInputComponents", obj["maxGeometryInputComponents"], (o.maxGeometryInputComponents)); + + parse_uint32_t("maxGeometryOutputComponents", obj["maxGeometryOutputComponents"], (o.maxGeometryOutputComponents)); + + parse_uint32_t("maxGeometryOutputVertices", obj["maxGeometryOutputVertices"], (o.maxGeometryOutputVertices)); + + parse_uint32_t("maxGeometryTotalOutputComponents", obj["maxGeometryTotalOutputComponents"], (o.maxGeometryTotalOutputComponents)); + + parse_uint32_t("maxFragmentInputComponents", obj["maxFragmentInputComponents"], (o.maxFragmentInputComponents)); + + parse_uint32_t("maxFragmentOutputAttachments", obj["maxFragmentOutputAttachments"], (o.maxFragmentOutputAttachments)); + + parse_uint32_t("maxFragmentDualSrcAttachments", obj["maxFragmentDualSrcAttachments"], (o.maxFragmentDualSrcAttachments)); + + parse_uint32_t("maxFragmentCombinedOutputResources", obj["maxFragmentCombinedOutputResources"], (o.maxFragmentCombinedOutputResources)); + + parse_uint32_t("maxComputeSharedMemorySize", obj["maxComputeSharedMemorySize"], (o.maxComputeSharedMemorySize)); + + Json::Value& obj_maxComputeWorkGroupCount_arr = obj["maxComputeWorkGroupCount"]; + for (unsigned int i = 0; i < obj_maxComputeWorkGroupCount_arr.size(); i++) { + parse_uint32_t("maxComputeWorkGroupCount", obj_maxComputeWorkGroupCount_arr[i], const_cast((o.maxComputeWorkGroupCount[i]))); + } + + parse_uint32_t("maxComputeWorkGroupInvocations", obj["maxComputeWorkGroupInvocations"], (o.maxComputeWorkGroupInvocations)); + + Json::Value& obj_maxComputeWorkGroupSize_arr = obj["maxComputeWorkGroupSize"]; + for (unsigned int i = 0; i < obj_maxComputeWorkGroupSize_arr.size(); i++) { + parse_uint32_t("maxComputeWorkGroupSize", obj_maxComputeWorkGroupSize_arr[i], const_cast((o.maxComputeWorkGroupSize[i]))); + } + + parse_uint32_t("subPixelPrecisionBits", obj["subPixelPrecisionBits"], (o.subPixelPrecisionBits)); + + parse_uint32_t("subTexelPrecisionBits", obj["subTexelPrecisionBits"], (o.subTexelPrecisionBits)); + + parse_uint32_t("mipmapPrecisionBits", obj["mipmapPrecisionBits"], (o.mipmapPrecisionBits)); + + parse_uint32_t("maxDrawIndexedIndexValue", obj["maxDrawIndexedIndexValue"], (o.maxDrawIndexedIndexValue)); + + parse_uint32_t("maxDrawIndirectCount", obj["maxDrawIndirectCount"], (o.maxDrawIndirectCount)); + + parse_float("maxSamplerLodBias", obj["maxSamplerLodBias"], (o.maxSamplerLodBias)); + + parse_float("maxSamplerAnisotropy", obj["maxSamplerAnisotropy"], (o.maxSamplerAnisotropy)); + + parse_uint32_t("maxViewports", obj["maxViewports"], (o.maxViewports)); + + Json::Value& obj_maxViewportDimensions_arr = obj["maxViewportDimensions"]; + for (unsigned int i = 0; i < obj_maxViewportDimensions_arr.size(); i++) { + parse_uint32_t("maxViewportDimensions", obj_maxViewportDimensions_arr[i], const_cast((o.maxViewportDimensions[i]))); + } + + Json::Value& obj_viewportBoundsRange_arr = obj["viewportBoundsRange"]; + for (unsigned int i = 0; i < obj_viewportBoundsRange_arr.size(); i++) { + parse_float("viewportBoundsRange", obj_viewportBoundsRange_arr[i], const_cast((o.viewportBoundsRange[i]))); + } + + parse_uint32_t("viewportSubPixelBits", obj["viewportSubPixelBits"], (o.viewportSubPixelBits)); + + parse_size_t("minMemoryMapAlignment", obj["minMemoryMapAlignment"], (o.minMemoryMapAlignment)); + + parse_VkDeviceSize("minTexelBufferOffsetAlignment", obj["minTexelBufferOffsetAlignment"], (o.minTexelBufferOffsetAlignment)); + + parse_VkDeviceSize("minUniformBufferOffsetAlignment", obj["minUniformBufferOffsetAlignment"], (o.minUniformBufferOffsetAlignment)); + + parse_VkDeviceSize("minStorageBufferOffsetAlignment", obj["minStorageBufferOffsetAlignment"], (o.minStorageBufferOffsetAlignment)); + + parse_int32_t("minTexelOffset", obj["minTexelOffset"], (o.minTexelOffset)); + + parse_uint32_t("maxTexelOffset", obj["maxTexelOffset"], (o.maxTexelOffset)); + + parse_int32_t("minTexelGatherOffset", obj["minTexelGatherOffset"], (o.minTexelGatherOffset)); + + parse_uint32_t("maxTexelGatherOffset", obj["maxTexelGatherOffset"], (o.maxTexelGatherOffset)); + + parse_float("minInterpolationOffset", obj["minInterpolationOffset"], (o.minInterpolationOffset)); + + parse_float("maxInterpolationOffset", obj["maxInterpolationOffset"], (o.maxInterpolationOffset)); + + parse_uint32_t("subPixelInterpolationOffsetBits", obj["subPixelInterpolationOffsetBits"], (o.subPixelInterpolationOffsetBits)); + + parse_uint32_t("maxFramebufferWidth", obj["maxFramebufferWidth"], (o.maxFramebufferWidth)); + + parse_uint32_t("maxFramebufferHeight", obj["maxFramebufferHeight"], (o.maxFramebufferHeight)); + + parse_uint32_t("maxFramebufferLayers", obj["maxFramebufferLayers"], (o.maxFramebufferLayers)); + + parse_VkSampleCountFlags("framebufferColorSampleCounts", obj["framebufferColorSampleCounts"], (o.framebufferColorSampleCounts)); + + parse_VkSampleCountFlags("framebufferDepthSampleCounts", obj["framebufferDepthSampleCounts"], (o.framebufferDepthSampleCounts)); + + parse_VkSampleCountFlags("framebufferStencilSampleCounts", obj["framebufferStencilSampleCounts"], (o.framebufferStencilSampleCounts)); + + parse_VkSampleCountFlags("framebufferNoAttachmentsSampleCounts", obj["framebufferNoAttachmentsSampleCounts"], (o.framebufferNoAttachmentsSampleCounts)); + + parse_uint32_t("maxColorAttachments", obj["maxColorAttachments"], (o.maxColorAttachments)); + + parse_VkSampleCountFlags("sampledImageColorSampleCounts", obj["sampledImageColorSampleCounts"], (o.sampledImageColorSampleCounts)); + + parse_VkSampleCountFlags("sampledImageIntegerSampleCounts", obj["sampledImageIntegerSampleCounts"], (o.sampledImageIntegerSampleCounts)); + + parse_VkSampleCountFlags("sampledImageDepthSampleCounts", obj["sampledImageDepthSampleCounts"], (o.sampledImageDepthSampleCounts)); + + parse_VkSampleCountFlags("sampledImageStencilSampleCounts", obj["sampledImageStencilSampleCounts"], (o.sampledImageStencilSampleCounts)); + + parse_VkSampleCountFlags("storageImageSampleCounts", obj["storageImageSampleCounts"], (o.storageImageSampleCounts)); + + parse_uint32_t("maxSampleMaskWords", obj["maxSampleMaskWords"], (o.maxSampleMaskWords)); + + parse_VkBool32("timestampComputeAndGraphics", obj["timestampComputeAndGraphics"], (o.timestampComputeAndGraphics)); + + parse_float("timestampPeriod", obj["timestampPeriod"], (o.timestampPeriod)); + + parse_uint32_t("maxClipDistances", obj["maxClipDistances"], (o.maxClipDistances)); + + parse_uint32_t("maxCullDistances", obj["maxCullDistances"], (o.maxCullDistances)); + + parse_uint32_t("maxCombinedClipAndCullDistances", obj["maxCombinedClipAndCullDistances"], (o.maxCombinedClipAndCullDistances)); + + parse_uint32_t("discreteQueuePriorities", obj["discreteQueuePriorities"], (o.discreteQueuePriorities)); + + Json::Value& obj_pointSizeRange_arr = obj["pointSizeRange"]; + for (unsigned int i = 0; i < obj_pointSizeRange_arr.size(); i++) { + parse_float("pointSizeRange", obj_pointSizeRange_arr[i], const_cast((o.pointSizeRange[i]))); + } + + Json::Value& obj_lineWidthRange_arr = obj["lineWidthRange"]; + for (unsigned int i = 0; i < obj_lineWidthRange_arr.size(); i++) { + parse_float("lineWidthRange", obj_lineWidthRange_arr[i], const_cast((o.lineWidthRange[i]))); + } + + parse_float("pointSizeGranularity", obj["pointSizeGranularity"], (o.pointSizeGranularity)); + + parse_float("lineWidthGranularity", obj["lineWidthGranularity"], (o.lineWidthGranularity)); + + parse_VkBool32("strictLines", obj["strictLines"], (o.strictLines)); + + parse_VkBool32("standardSampleLocations", obj["standardSampleLocations"], (o.standardSampleLocations)); + + parse_VkDeviceSize("optimalBufferCopyOffsetAlignment", obj["optimalBufferCopyOffsetAlignment"], (o.optimalBufferCopyOffsetAlignment)); + + parse_VkDeviceSize("optimalBufferCopyRowPitchAlignment", obj["optimalBufferCopyRowPitchAlignment"], (o.optimalBufferCopyRowPitchAlignment)); + + parse_VkDeviceSize("nonCoherentAtomSize", obj["nonCoherentAtomSize"], (o.nonCoherentAtomSize)); + +} + +static void parse_VkPhysicalDeviceMemoryProperties(const char* s, Json::Value& obj, VkPhysicalDeviceMemoryProperties& o) { + + parse_uint32_t("memoryTypeCount", obj["memoryTypeCount"], (o.memoryTypeCount)); + + Json::Value& obj_memoryTypes_arr = obj["memoryTypes"]; + for (unsigned int i = 0; i < obj_memoryTypes_arr.size(); i++) { + parse_VkMemoryType("memoryTypes", obj_memoryTypes_arr[i], const_cast((o.memoryTypes[i]))); + } + + parse_uint32_t("memoryHeapCount", obj["memoryHeapCount"], (o.memoryHeapCount)); + + Json::Value& obj_memoryHeaps_arr = obj["memoryHeaps"]; + for (unsigned int i = 0; i < obj_memoryHeaps_arr.size(); i++) { + parse_VkMemoryHeap("memoryHeaps", obj_memoryHeaps_arr[i], const_cast((o.memoryHeaps[i]))); + } + +} + +static void parse_VkPhysicalDeviceSparseProperties(const char* s, Json::Value& obj, VkPhysicalDeviceSparseProperties& o) { + + parse_VkBool32("residencyStandard2DBlockShape", obj["residencyStandard2DBlockShape"], (o.residencyStandard2DBlockShape)); + + parse_VkBool32("residencyStandard2DMultisampleBlockShape", obj["residencyStandard2DMultisampleBlockShape"], (o.residencyStandard2DMultisampleBlockShape)); + + parse_VkBool32("residencyStandard3DBlockShape", obj["residencyStandard3DBlockShape"], (o.residencyStandard3DBlockShape)); + + parse_VkBool32("residencyAlignedMipSize", obj["residencyAlignedMipSize"], (o.residencyAlignedMipSize)); + + parse_VkBool32("residencyNonResidentStrict", obj["residencyNonResidentStrict"], (o.residencyNonResidentStrict)); + +} + +static void parse_VkPhysicalDeviceProperties(const char* s, Json::Value& obj, VkPhysicalDeviceProperties& o) { + + parse_uint32_t("apiVersion", obj["apiVersion"], (o.apiVersion)); + + parse_uint32_t("driverVersion", obj["driverVersion"], (o.driverVersion)); + + parse_uint32_t("vendorID", obj["vendorID"], (o.vendorID)); + + parse_uint32_t("deviceID", obj["deviceID"], (o.deviceID)); + + parse_VkPhysicalDeviceType("deviceType", obj["deviceType"], (o.deviceType)); + + /** TODO: Handle this - deviceName **/ + + Json::Value& obj_pipelineCacheUUID_arr = obj["pipelineCacheUUID"]; + for (unsigned int i = 0; i < obj_pipelineCacheUUID_arr.size(); i++) { + parse_uint8_t("pipelineCacheUUID", obj_pipelineCacheUUID_arr[i], const_cast((o.pipelineCacheUUID[i]))); + } + + parse_VkPhysicalDeviceLimits("limits", obj["limits"], (o.limits)); + + parse_VkPhysicalDeviceSparseProperties("sparseProperties", obj["sparseProperties"], (o.sparseProperties)); + +} + +static void parse_VkQueueFamilyProperties(const char* s, Json::Value& obj, VkQueueFamilyProperties& o) { + + parse_VkQueueFlags("queueFlags", obj["queueFlags"], (o.queueFlags)); + + parse_uint32_t("queueCount", obj["queueCount"], (o.queueCount)); + + parse_uint32_t("timestampValidBits", obj["timestampValidBits"], (o.timestampValidBits)); + + parse_VkExtent3D("minImageTransferGranularity", obj["minImageTransferGranularity"], (o.minImageTransferGranularity)); + +} + +static void parse_VkDeviceQueueCreateInfo(const char* s, Json::Value& obj, VkDeviceQueueCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDeviceQueueCreateInfo*)parsePNextChain(obj); + + parse_VkDeviceQueueCreateFlags("flags", obj["flags"], (o.flags)); + + parse_uint32_t("queueFamilyIndex", obj["queueFamilyIndex"], (o.queueFamilyIndex)); + + parse_uint32_t("queueCount", obj["queueCount"], (o.queueCount)); + + (o.pQueuePriorities) = (float*)s_globalMem.allocate((o.queueCount), sizeof(float)); + Json::Value& obj_pQueuePriorities_arr = obj["pQueuePriorities"]; + for (unsigned int i = 0; i < obj_pQueuePriorities_arr.size(); i++) { + parse_float("pQueuePriorities", obj_pQueuePriorities_arr[i], const_cast((o.pQueuePriorities[i]))); + } + +} + +static void parse_VkDeviceCreateInfo(const char* s, Json::Value& obj, VkDeviceCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDeviceCreateInfo*)parsePNextChain(obj); + + parse_VkDeviceCreateFlags("flags", obj["flags"], (o.flags)); + + parse_uint32_t("queueCreateInfoCount", obj["queueCreateInfoCount"], (o.queueCreateInfoCount)); + + (o.pQueueCreateInfos) = (VkDeviceQueueCreateInfo*)s_globalMem.allocate((o.queueCreateInfoCount), sizeof(VkDeviceQueueCreateInfo)); + Json::Value& obj_pQueueCreateInfos = obj["pQueueCreateInfos"]; + if (obj_pQueueCreateInfos.size() == 0) (o.pQueueCreateInfos) = nullptr; + else { + for (unsigned int i = 0; i < (o.queueCreateInfoCount); i++) { + parse_VkDeviceQueueCreateInfo("pQueueCreateInfos", obj_pQueueCreateInfos[i], const_cast((o.pQueueCreateInfos[i]))); + } + } + + parse_uint32_t("enabledLayerCount", obj["enabledLayerCount"], (o.enabledLayerCount)); + + /** TODO: Handle this - ppEnabledLayerNames **/ + + parse_uint32_t("enabledExtensionCount", obj["enabledExtensionCount"], (o.enabledExtensionCount)); + + /** TODO: Handle this - ppEnabledExtensionNames **/ + + { + Json::Value& obj_pEnabledFeatures = obj["pEnabledFeatures"]; + const int sz = obj_pEnabledFeatures.size(); + if (obj_pEnabledFeatures.size() == 0) { + (o.pEnabledFeatures) = nullptr; + } else { + (o.pEnabledFeatures) = (VkPhysicalDeviceFeatures*)s_globalMem.allocate(1, sizeof(VkPhysicalDeviceFeatures)); + parse_VkPhysicalDeviceFeatures("pEnabledFeatures", obj_pEnabledFeatures, const_cast(*(o.pEnabledFeatures))); + } + } + +} + +static void parse_VkExtensionProperties(const char* s, Json::Value& obj, VkExtensionProperties& o) { + + /** TODO: Handle this - extensionName **/ + + parse_uint32_t("specVersion", obj["specVersion"], (o.specVersion)); + +} + +static void parse_VkLayerProperties(const char* s, Json::Value& obj, VkLayerProperties& o) { + + /** TODO: Handle this - layerName **/ + + parse_uint32_t("specVersion", obj["specVersion"], (o.specVersion)); + + parse_uint32_t("implementationVersion", obj["implementationVersion"], (o.implementationVersion)); + + /** TODO: Handle this - description **/ + +} + +static void parse_VkSubmitInfo(const char* s, Json::Value& obj, VkSubmitInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSubmitInfo*)parsePNextChain(obj); + + parse_uint32_t("waitSemaphoreCount", obj["waitSemaphoreCount"], (o.waitSemaphoreCount)); + + (o.pWaitSemaphores) = (VkSemaphore*)s_globalMem.allocate((o.waitSemaphoreCount), sizeof(VkSemaphore)); + Json::Value& obj_pWaitSemaphores_arr = obj["pWaitSemaphores"]; + for (unsigned int i = 0; i < obj_pWaitSemaphores_arr.size(); i++) { + parse_VkSemaphore("pWaitSemaphores", obj_pWaitSemaphores_arr[i], const_cast((o.pWaitSemaphores[i]))); + } + + (o.pWaitDstStageMask) = (VkPipelineStageFlags*)s_globalMem.allocate((o.waitSemaphoreCount), sizeof(VkPipelineStageFlags)); + Json::Value& obj_pWaitDstStageMask_arr = obj["pWaitDstStageMask"]; + for (unsigned int i = 0; i < obj_pWaitDstStageMask_arr.size(); i++) { + parse_VkPipelineStageFlags("pWaitDstStageMask", obj_pWaitDstStageMask_arr[i], const_cast((o.pWaitDstStageMask[i]))); + } + + parse_uint32_t("commandBufferCount", obj["commandBufferCount"], (o.commandBufferCount)); + + (o.pCommandBuffers) = (VkCommandBuffer*)s_globalMem.allocate((o.commandBufferCount), sizeof(VkCommandBuffer)); + Json::Value& obj_pCommandBuffers_arr = obj["pCommandBuffers"]; + for (unsigned int i = 0; i < obj_pCommandBuffers_arr.size(); i++) { + parse_VkCommandBuffer("pCommandBuffers", obj_pCommandBuffers_arr[i], const_cast((o.pCommandBuffers[i]))); + } + + parse_uint32_t("signalSemaphoreCount", obj["signalSemaphoreCount"], (o.signalSemaphoreCount)); + + (o.pSignalSemaphores) = (VkSemaphore*)s_globalMem.allocate((o.signalSemaphoreCount), sizeof(VkSemaphore)); + Json::Value& obj_pSignalSemaphores_arr = obj["pSignalSemaphores"]; + for (unsigned int i = 0; i < obj_pSignalSemaphores_arr.size(); i++) { + parse_VkSemaphore("pSignalSemaphores", obj_pSignalSemaphores_arr[i], const_cast((o.pSignalSemaphores[i]))); + } + +} + +static void parse_VkMappedMemoryRange(const char* s, Json::Value& obj, VkMappedMemoryRange& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkMappedMemoryRange*)parsePNextChain(obj); + + + parse_VkDeviceSize("offset", obj["offset"], (o.offset)); + + parse_VkDeviceSize("size", obj["size"], (o.size)); + +} + +static void parse_VkMemoryAllocateInfo(const char* s, Json::Value& obj, VkMemoryAllocateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkMemoryAllocateInfo*)parsePNextChain(obj); + + parse_VkDeviceSize("allocationSize", obj["allocationSize"], (o.allocationSize)); + + parse_uint32_t("memoryTypeIndex", obj["memoryTypeIndex"], (o.memoryTypeIndex)); + +} + +static void parse_VkMemoryRequirements(const char* s, Json::Value& obj, VkMemoryRequirements& o) { + + parse_VkDeviceSize("size", obj["size"], (o.size)); + + parse_VkDeviceSize("alignment", obj["alignment"], (o.alignment)); + + parse_uint32_t("memoryTypeBits", obj["memoryTypeBits"], (o.memoryTypeBits)); + +} + +static void parse_VkImageSubresource(const char* s, Json::Value& obj, VkImageSubresource& o) { + + parse_VkImageAspectFlags("aspectMask", obj["aspectMask"], (o.aspectMask)); + + parse_uint32_t("mipLevel", obj["mipLevel"], (o.mipLevel)); + + parse_uint32_t("arrayLayer", obj["arrayLayer"], (o.arrayLayer)); + +} + +static void parse_VkFenceCreateInfo(const char* s, Json::Value& obj, VkFenceCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkFenceCreateInfo*)parsePNextChain(obj); + + parse_VkFenceCreateFlags("flags", obj["flags"], (o.flags)); + +} + +static void parse_VkSemaphoreCreateInfo(const char* s, Json::Value& obj, VkSemaphoreCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSemaphoreCreateInfo*)parsePNextChain(obj); + + parse_VkSemaphoreCreateFlags("flags", obj["flags"], (o.flags)); + +} + +static void parse_VkEventCreateInfo(const char* s, Json::Value& obj, VkEventCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkEventCreateInfo*)parsePNextChain(obj); + + parse_VkEventCreateFlags("flags", obj["flags"], (o.flags)); + +} + +static void parse_VkQueryPoolCreateInfo(const char* s, Json::Value& obj, VkQueryPoolCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkQueryPoolCreateInfo*)parsePNextChain(obj); + + parse_VkQueryPoolCreateFlags("flags", obj["flags"], (o.flags)); + + parse_VkQueryType("queryType", obj["queryType"], (o.queryType)); + + parse_uint32_t("queryCount", obj["queryCount"], (o.queryCount)); + + parse_VkQueryPipelineStatisticFlags("pipelineStatistics", obj["pipelineStatistics"], (o.pipelineStatistics)); + +} + +static void parse_VkBufferCreateInfo(const char* s, Json::Value& obj, VkBufferCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkBufferCreateInfo*)parsePNextChain(obj); + + parse_VkBufferCreateFlags("flags", obj["flags"], (o.flags)); + + parse_VkDeviceSize("size", obj["size"], (o.size)); + + parse_VkBufferUsageFlags("usage", obj["usage"], (o.usage)); + + parse_VkSharingMode("sharingMode", obj["sharingMode"], (o.sharingMode)); + + parse_uint32_t("queueFamilyIndexCount", obj["queueFamilyIndexCount"], (o.queueFamilyIndexCount)); + + (o.pQueueFamilyIndices) = (uint32_t*)s_globalMem.allocate((o.queueFamilyIndexCount), sizeof(uint32_t)); + Json::Value& obj_pQueueFamilyIndices_arr = obj["pQueueFamilyIndices"]; + for (unsigned int i = 0; i < obj_pQueueFamilyIndices_arr.size(); i++) { + parse_uint32_t("pQueueFamilyIndices", obj_pQueueFamilyIndices_arr[i], const_cast((o.pQueueFamilyIndices[i]))); + } + +} + +static void parse_VkBufferViewCreateInfo(const char* s, Json::Value& obj, VkBufferViewCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkBufferViewCreateInfo*)parsePNextChain(obj); + + parse_VkBufferViewCreateFlags("flags", obj["flags"], (o.flags)); + + + parse_VkFormat("format", obj["format"], (o.format)); + + parse_VkDeviceSize("offset", obj["offset"], (o.offset)); + + parse_VkDeviceSize("range", obj["range"], (o.range)); + +} + +static void parse_VkImageCreateInfo(const char* s, Json::Value& obj, VkImageCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImageCreateInfo*)parsePNextChain(obj); + + parse_VkImageCreateFlags("flags", obj["flags"], (o.flags)); + + parse_VkImageType("imageType", obj["imageType"], (o.imageType)); + + parse_VkFormat("format", obj["format"], (o.format)); + + parse_VkExtent3D("extent", obj["extent"], (o.extent)); + + parse_uint32_t("mipLevels", obj["mipLevels"], (o.mipLevels)); + + parse_uint32_t("arrayLayers", obj["arrayLayers"], (o.arrayLayers)); + + parse_VkSampleCountFlagBits("samples", obj["samples"], (o.samples)); + + parse_VkImageTiling("tiling", obj["tiling"], (o.tiling)); + + parse_VkImageUsageFlags("usage", obj["usage"], (o.usage)); + + parse_VkSharingMode("sharingMode", obj["sharingMode"], (o.sharingMode)); + + parse_uint32_t("queueFamilyIndexCount", obj["queueFamilyIndexCount"], (o.queueFamilyIndexCount)); + + (o.pQueueFamilyIndices) = (uint32_t*)s_globalMem.allocate((o.queueFamilyIndexCount), sizeof(uint32_t)); + Json::Value& obj_pQueueFamilyIndices_arr = obj["pQueueFamilyIndices"]; + for (unsigned int i = 0; i < obj_pQueueFamilyIndices_arr.size(); i++) { + parse_uint32_t("pQueueFamilyIndices", obj_pQueueFamilyIndices_arr[i], const_cast((o.pQueueFamilyIndices[i]))); + } + + parse_VkImageLayout("initialLayout", obj["initialLayout"], (o.initialLayout)); + +} + +static void parse_VkSubresourceLayout(const char* s, Json::Value& obj, VkSubresourceLayout& o) { + + parse_VkDeviceSize("offset", obj["offset"], (o.offset)); + + parse_VkDeviceSize("size", obj["size"], (o.size)); + + parse_VkDeviceSize("rowPitch", obj["rowPitch"], (o.rowPitch)); + + parse_VkDeviceSize("arrayPitch", obj["arrayPitch"], (o.arrayPitch)); + + parse_VkDeviceSize("depthPitch", obj["depthPitch"], (o.depthPitch)); + +} + +static void parse_VkComponentMapping(const char* s, Json::Value& obj, VkComponentMapping& o) { + + parse_VkComponentSwizzle("r", obj["r"], (o.r)); + + parse_VkComponentSwizzle("g", obj["g"], (o.g)); + + parse_VkComponentSwizzle("b", obj["b"], (o.b)); + + parse_VkComponentSwizzle("a", obj["a"], (o.a)); + +} + +static void parse_VkImageViewCreateInfo(const char* s, Json::Value& obj, VkImageViewCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImageViewCreateInfo*)parsePNextChain(obj); + + parse_VkImageViewCreateFlags("flags", obj["flags"], (o.flags)); + + + parse_VkImageViewType("viewType", obj["viewType"], (o.viewType)); + + parse_VkFormat("format", obj["format"], (o.format)); + + parse_VkComponentMapping("components", obj["components"], (o.components)); + + parse_VkImageSubresourceRange("subresourceRange", obj["subresourceRange"], (o.subresourceRange)); + +} + +static void parse_VkPipelineCacheCreateInfo(const char* s, Json::Value& obj, VkPipelineCacheCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineCacheCreateInfo*)parsePNextChain(obj); + + parse_VkPipelineCacheCreateFlags("flags", obj["flags"], (o.flags)); + + parse_size_t("initialDataSize", obj["initialDataSize"], (o.initialDataSize)); + + /** Note: Ignoring void* data. **/ + +} + +static void parse_VkSpecializationMapEntry(const char* s, Json::Value& obj, VkSpecializationMapEntry& o) { + + parse_uint32_t("constantID", obj["constantID"], (o.constantID)); + + parse_uint32_t("offset", obj["offset"], (o.offset)); + + parse_size_t("size", obj["size"], (o.size)); + +} + +static void parse_VkSpecializationInfo(const char* s, Json::Value& obj, VkSpecializationInfo& o) { + + parse_uint32_t("mapEntryCount", obj["mapEntryCount"], (o.mapEntryCount)); + + (o.pMapEntries) = (VkSpecializationMapEntry*)s_globalMem.allocate((o.mapEntryCount), sizeof(VkSpecializationMapEntry)); + Json::Value& obj_pMapEntries = obj["pMapEntries"]; + if (obj_pMapEntries.size() == 0) (o.pMapEntries) = nullptr; + else { + for (unsigned int i = 0; i < (o.mapEntryCount); i++) { + parse_VkSpecializationMapEntry("pMapEntries", obj_pMapEntries[i], const_cast((o.pMapEntries[i]))); + } + } + + parse_size_t("dataSize", obj["dataSize"], (o.dataSize)); + + if (o.dataSize > 0U) + { + void* data = s_globalMem.allocate(uint32_t(o.dataSize)); + parse_void_data("pData", obj["pData"], data, int(o.dataSize)); + o.pData = data; + } + else + o.pData = NULL; + +} + +static void parse_VkPipelineShaderStageCreateInfo(const char* s, Json::Value& obj, VkPipelineShaderStageCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineShaderStageCreateInfo*)parsePNextChain(obj); + + parse_VkPipelineShaderStageCreateFlags("flags", obj["flags"], (o.flags)); + + parse_VkShaderStageFlagBits("stage", obj["stage"], (o.stage)); + + + (o.pName) = (const char*)s_globalMem.allocate(255); + parse_char("pName", obj["pName"], &(o.pName)); + + { + Json::Value& obj_pSpecializationInfo = obj["pSpecializationInfo"]; + const int sz = obj_pSpecializationInfo.size(); + if (obj_pSpecializationInfo.size() == 0) { + (o.pSpecializationInfo) = nullptr; + } else { + (o.pSpecializationInfo) = (VkSpecializationInfo*)s_globalMem.allocate(1, sizeof(VkSpecializationInfo)); + parse_VkSpecializationInfo("pSpecializationInfo", obj_pSpecializationInfo, const_cast(*(o.pSpecializationInfo))); + } + } + +} + +static void parse_VkComputePipelineCreateInfo(const char* s, Json::Value& obj, VkComputePipelineCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkComputePipelineCreateInfo*)parsePNextChain(obj); + + parse_VkPipelineCreateFlags("flags", obj["flags"], (o.flags)); + + parse_VkPipelineShaderStageCreateInfo("stage", obj["stage"], (o.stage)); + + + + parse_int32_t("basePipelineIndex", obj["basePipelineIndex"], (o.basePipelineIndex)); + +} + +static void parse_VkVertexInputBindingDescription(const char* s, Json::Value& obj, VkVertexInputBindingDescription& o) { + + parse_uint32_t("binding", obj["binding"], (o.binding)); + + parse_uint32_t("stride", obj["stride"], (o.stride)); + + parse_VkVertexInputRate("inputRate", obj["inputRate"], (o.inputRate)); + +} + +static void parse_VkVertexInputAttributeDescription(const char* s, Json::Value& obj, VkVertexInputAttributeDescription& o) { + + parse_uint32_t("location", obj["location"], (o.location)); + + parse_uint32_t("binding", obj["binding"], (o.binding)); + + parse_VkFormat("format", obj["format"], (o.format)); + + parse_uint32_t("offset", obj["offset"], (o.offset)); + +} + +static void parse_VkPipelineVertexInputStateCreateInfo(const char* s, Json::Value& obj, VkPipelineVertexInputStateCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineVertexInputStateCreateInfo*)parsePNextChain(obj); + + parse_VkPipelineVertexInputStateCreateFlags("flags", obj["flags"], (o.flags)); + + parse_uint32_t("vertexBindingDescriptionCount", obj["vertexBindingDescriptionCount"], (o.vertexBindingDescriptionCount)); + + (o.pVertexBindingDescriptions) = (VkVertexInputBindingDescription*)s_globalMem.allocate((o.vertexBindingDescriptionCount), sizeof(VkVertexInputBindingDescription)); + Json::Value& obj_pVertexBindingDescriptions = obj["pVertexBindingDescriptions"]; + if (obj_pVertexBindingDescriptions.size() == 0) (o.pVertexBindingDescriptions) = nullptr; + else { + for (unsigned int i = 0; i < (o.vertexBindingDescriptionCount); i++) { + parse_VkVertexInputBindingDescription("pVertexBindingDescriptions", obj_pVertexBindingDescriptions[i], const_cast((o.pVertexBindingDescriptions[i]))); + } + } + + parse_uint32_t("vertexAttributeDescriptionCount", obj["vertexAttributeDescriptionCount"], (o.vertexAttributeDescriptionCount)); + + (o.pVertexAttributeDescriptions) = (VkVertexInputAttributeDescription*)s_globalMem.allocate((o.vertexAttributeDescriptionCount), sizeof(VkVertexInputAttributeDescription)); + Json::Value& obj_pVertexAttributeDescriptions = obj["pVertexAttributeDescriptions"]; + if (obj_pVertexAttributeDescriptions.size() == 0) (o.pVertexAttributeDescriptions) = nullptr; + else { + for (unsigned int i = 0; i < (o.vertexAttributeDescriptionCount); i++) { + parse_VkVertexInputAttributeDescription("pVertexAttributeDescriptions", obj_pVertexAttributeDescriptions[i], const_cast((o.pVertexAttributeDescriptions[i]))); + } + } + +} + +static void parse_VkPipelineInputAssemblyStateCreateInfo(const char* s, Json::Value& obj, VkPipelineInputAssemblyStateCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineInputAssemblyStateCreateInfo*)parsePNextChain(obj); + + parse_VkPipelineInputAssemblyStateCreateFlags("flags", obj["flags"], (o.flags)); + + parse_VkPrimitiveTopology("topology", obj["topology"], (o.topology)); + + parse_VkBool32("primitiveRestartEnable", obj["primitiveRestartEnable"], (o.primitiveRestartEnable)); + +} + +static void parse_VkPipelineTessellationStateCreateInfo(const char* s, Json::Value& obj, VkPipelineTessellationStateCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineTessellationStateCreateInfo*)parsePNextChain(obj); + + parse_VkPipelineTessellationStateCreateFlags("flags", obj["flags"], (o.flags)); + + parse_uint32_t("patchControlPoints", obj["patchControlPoints"], (o.patchControlPoints)); + +} + +static void parse_VkViewport(const char* s, Json::Value& obj, VkViewport& o) { + + parse_float("x", obj["x"], (o.x)); + + parse_float("y", obj["y"], (o.y)); + + parse_float("width", obj["width"], (o.width)); + + parse_float("height", obj["height"], (o.height)); + + parse_float("minDepth", obj["minDepth"], (o.minDepth)); + + parse_float("maxDepth", obj["maxDepth"], (o.maxDepth)); + +} + +static void parse_VkPipelineViewportStateCreateInfo(const char* s, Json::Value& obj, VkPipelineViewportStateCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineViewportStateCreateInfo*)parsePNextChain(obj); + + parse_VkPipelineViewportStateCreateFlags("flags", obj["flags"], (o.flags)); + + parse_uint32_t("viewportCount", obj["viewportCount"], (o.viewportCount)); + + (o.pViewports) = (VkViewport*)s_globalMem.allocate((o.viewportCount), sizeof(VkViewport)); + Json::Value& obj_pViewports = obj["pViewports"]; + if (obj_pViewports.size() == 0) (o.pViewports) = nullptr; + else { + for (unsigned int i = 0; i < (o.viewportCount); i++) { + parse_VkViewport("pViewports", obj_pViewports[i], const_cast((o.pViewports[i]))); + } + } + + parse_uint32_t("scissorCount", obj["scissorCount"], (o.scissorCount)); + + (o.pScissors) = (VkRect2D*)s_globalMem.allocate((o.scissorCount), sizeof(VkRect2D)); + Json::Value& obj_pScissors = obj["pScissors"]; + if (obj_pScissors.size() == 0) (o.pScissors) = nullptr; + else { + for (unsigned int i = 0; i < (o.scissorCount); i++) { + parse_VkRect2D("pScissors", obj_pScissors[i], const_cast((o.pScissors[i]))); + } + } + +} + +static void parse_VkPipelineRasterizationStateCreateInfo(const char* s, Json::Value& obj, VkPipelineRasterizationStateCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineRasterizationStateCreateInfo*)parsePNextChain(obj); + + parse_VkPipelineRasterizationStateCreateFlags("flags", obj["flags"], (o.flags)); + + parse_VkBool32("depthClampEnable", obj["depthClampEnable"], (o.depthClampEnable)); + + parse_VkBool32("rasterizerDiscardEnable", obj["rasterizerDiscardEnable"], (o.rasterizerDiscardEnable)); + + parse_VkPolygonMode("polygonMode", obj["polygonMode"], (o.polygonMode)); + + parse_VkCullModeFlags("cullMode", obj["cullMode"], (o.cullMode)); + + parse_VkFrontFace("frontFace", obj["frontFace"], (o.frontFace)); + + parse_VkBool32("depthBiasEnable", obj["depthBiasEnable"], (o.depthBiasEnable)); + + parse_float("depthBiasConstantFactor", obj["depthBiasConstantFactor"], (o.depthBiasConstantFactor)); + + parse_float("depthBiasClamp", obj["depthBiasClamp"], (o.depthBiasClamp)); + + parse_float("depthBiasSlopeFactor", obj["depthBiasSlopeFactor"], (o.depthBiasSlopeFactor)); + + parse_float("lineWidth", obj["lineWidth"], (o.lineWidth)); + +} + +static void parse_VkPipelineMultisampleStateCreateInfo(const char* s, Json::Value& obj, VkPipelineMultisampleStateCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineMultisampleStateCreateInfo*)parsePNextChain(obj); + + parse_VkPipelineMultisampleStateCreateFlags("flags", obj["flags"], (o.flags)); + + parse_VkSampleCountFlagBits("rasterizationSamples", obj["rasterizationSamples"], (o.rasterizationSamples)); + + parse_VkBool32("sampleShadingEnable", obj["sampleShadingEnable"], (o.sampleShadingEnable)); + + parse_float("minSampleShading", obj["minSampleShading"], (o.minSampleShading)); + + (o.pSampleMask) = (VkSampleMask*)s_globalMem.allocate((uint32_t(o.rasterizationSamples + 31) / 32), sizeof(VkSampleMask)); + Json::Value& obj_pSampleMask = obj["pSampleMask"]; + if (o.rasterizationSamples == 0 || obj_pSampleMask.size() == 0) { + (o.pSampleMask) = nullptr; + } else { + for (uint32_t i = 0; i < (uint32_t(o.rasterizationSamples + 31) / 32); i++) { + parse_uint32_t("pSampleMask", obj_pSampleMask[i], const_cast((o.pSampleMask[i]))); + } + } + + parse_VkBool32("alphaToCoverageEnable", obj["alphaToCoverageEnable"], (o.alphaToCoverageEnable)); + + parse_VkBool32("alphaToOneEnable", obj["alphaToOneEnable"], (o.alphaToOneEnable)); + +} + +static void parse_VkStencilOpState(const char* s, Json::Value& obj, VkStencilOpState& o) { + + parse_VkStencilOp("failOp", obj["failOp"], (o.failOp)); + + parse_VkStencilOp("passOp", obj["passOp"], (o.passOp)); + + parse_VkStencilOp("depthFailOp", obj["depthFailOp"], (o.depthFailOp)); + + parse_VkCompareOp("compareOp", obj["compareOp"], (o.compareOp)); + + parse_uint32_t("compareMask", obj["compareMask"], (o.compareMask)); + + parse_uint32_t("writeMask", obj["writeMask"], (o.writeMask)); + + parse_uint32_t("reference", obj["reference"], (o.reference)); + +} + +static void parse_VkPipelineDepthStencilStateCreateInfo(const char* s, Json::Value& obj, VkPipelineDepthStencilStateCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineDepthStencilStateCreateInfo*)parsePNextChain(obj); + + parse_VkPipelineDepthStencilStateCreateFlags("flags", obj["flags"], (o.flags)); + + parse_VkBool32("depthTestEnable", obj["depthTestEnable"], (o.depthTestEnable)); + + parse_VkBool32("depthWriteEnable", obj["depthWriteEnable"], (o.depthWriteEnable)); + + parse_VkCompareOp("depthCompareOp", obj["depthCompareOp"], (o.depthCompareOp)); + + parse_VkBool32("depthBoundsTestEnable", obj["depthBoundsTestEnable"], (o.depthBoundsTestEnable)); + + parse_VkBool32("stencilTestEnable", obj["stencilTestEnable"], (o.stencilTestEnable)); + + parse_VkStencilOpState("front", obj["front"], (o.front)); + + parse_VkStencilOpState("back", obj["back"], (o.back)); + + parse_float("minDepthBounds", obj["minDepthBounds"], (o.minDepthBounds)); + + parse_float("maxDepthBounds", obj["maxDepthBounds"], (o.maxDepthBounds)); + +} + +static void parse_VkPipelineColorBlendAttachmentState(const char* s, Json::Value& obj, VkPipelineColorBlendAttachmentState& o) { + + parse_VkBool32("blendEnable", obj["blendEnable"], (o.blendEnable)); + + parse_VkBlendFactor("srcColorBlendFactor", obj["srcColorBlendFactor"], (o.srcColorBlendFactor)); + + parse_VkBlendFactor("dstColorBlendFactor", obj["dstColorBlendFactor"], (o.dstColorBlendFactor)); + + parse_VkBlendOp("colorBlendOp", obj["colorBlendOp"], (o.colorBlendOp)); + + parse_VkBlendFactor("srcAlphaBlendFactor", obj["srcAlphaBlendFactor"], (o.srcAlphaBlendFactor)); + + parse_VkBlendFactor("dstAlphaBlendFactor", obj["dstAlphaBlendFactor"], (o.dstAlphaBlendFactor)); + + parse_VkBlendOp("alphaBlendOp", obj["alphaBlendOp"], (o.alphaBlendOp)); + + parse_VkColorComponentFlags("colorWriteMask", obj["colorWriteMask"], (o.colorWriteMask)); + +} + +static void parse_VkPipelineColorBlendStateCreateInfo(const char* s, Json::Value& obj, VkPipelineColorBlendStateCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineColorBlendStateCreateInfo*)parsePNextChain(obj); + + parse_VkPipelineColorBlendStateCreateFlags("flags", obj["flags"], (o.flags)); + + parse_VkBool32("logicOpEnable", obj["logicOpEnable"], (o.logicOpEnable)); + + parse_VkLogicOp("logicOp", obj["logicOp"], (o.logicOp)); + + parse_uint32_t("attachmentCount", obj["attachmentCount"], (o.attachmentCount)); + + (o.pAttachments) = (VkPipelineColorBlendAttachmentState*)s_globalMem.allocate((o.attachmentCount), sizeof(VkPipelineColorBlendAttachmentState)); + Json::Value& obj_pAttachments = obj["pAttachments"]; + if (obj_pAttachments.size() == 0) (o.pAttachments) = nullptr; + else { + for (unsigned int i = 0; i < (o.attachmentCount); i++) { + parse_VkPipelineColorBlendAttachmentState("pAttachments", obj_pAttachments[i], const_cast((o.pAttachments[i]))); + } + } + + Json::Value& obj_blendConstants_arr = obj["blendConstants"]; + for (unsigned int i = 0; i < obj_blendConstants_arr.size(); i++) { + parse_float("blendConstants", obj_blendConstants_arr[i], const_cast((o.blendConstants[i]))); + } + +} + +static void parse_VkPipelineDynamicStateCreateInfo(const char* s, Json::Value& obj, VkPipelineDynamicStateCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineDynamicStateCreateInfo*)parsePNextChain(obj); + + parse_VkPipelineDynamicStateCreateFlags("flags", obj["flags"], (o.flags)); + + parse_uint32_t("dynamicStateCount", obj["dynamicStateCount"], (o.dynamicStateCount)); + + (o.pDynamicStates) = (VkDynamicState*)s_globalMem.allocate((o.dynamicStateCount), sizeof(VkDynamicState)); + Json::Value& obj_pDynamicStates_arr = obj["pDynamicStates"]; + for (unsigned int i = 0; i < obj_pDynamicStates_arr.size(); i++) { + parse_VkDynamicState("pDynamicStates", obj_pDynamicStates_arr[i], const_cast((o.pDynamicStates[i]))); + } + +} + +static void parse_VkGraphicsPipelineCreateInfo(const char* s, Json::Value& obj, VkGraphicsPipelineCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkGraphicsPipelineCreateInfo*)parsePNextChain(obj); + + parse_VkPipelineCreateFlags("flags", obj["flags"], (o.flags)); + + parse_uint32_t("stageCount", obj["stageCount"], (o.stageCount)); + + (o.pStages) = (VkPipelineShaderStageCreateInfo*)s_globalMem.allocate((o.stageCount), sizeof(VkPipelineShaderStageCreateInfo)); + Json::Value& obj_pStages = obj["pStages"]; + if (obj_pStages.size() == 0) (o.pStages) = nullptr; + else { + for (unsigned int i = 0; i < (o.stageCount); i++) { + parse_VkPipelineShaderStageCreateInfo("pStages", obj_pStages[i], const_cast((o.pStages[i]))); + } + } + + { + Json::Value& obj_pVertexInputState = obj["pVertexInputState"]; + const int sz = obj_pVertexInputState.size(); + if (obj_pVertexInputState.size() == 0) { + (o.pVertexInputState) = nullptr; + } else { + (o.pVertexInputState) = (VkPipelineVertexInputStateCreateInfo*)s_globalMem.allocate(1, sizeof(VkPipelineVertexInputStateCreateInfo)); + parse_VkPipelineVertexInputStateCreateInfo("pVertexInputState", obj_pVertexInputState, const_cast(*(o.pVertexInputState))); + } + } + + { + Json::Value& obj_pInputAssemblyState = obj["pInputAssemblyState"]; + const int sz = obj_pInputAssemblyState.size(); + if (obj_pInputAssemblyState.size() == 0) { + (o.pInputAssemblyState) = nullptr; + } else { + (o.pInputAssemblyState) = (VkPipelineInputAssemblyStateCreateInfo*)s_globalMem.allocate(1, sizeof(VkPipelineInputAssemblyStateCreateInfo)); + parse_VkPipelineInputAssemblyStateCreateInfo("pInputAssemblyState", obj_pInputAssemblyState, const_cast(*(o.pInputAssemblyState))); + } + } + + { + Json::Value& obj_pTessellationState = obj["pTessellationState"]; + const int sz = obj_pTessellationState.size(); + if (obj_pTessellationState.size() == 0) { + (o.pTessellationState) = nullptr; + } else { + (o.pTessellationState) = (VkPipelineTessellationStateCreateInfo*)s_globalMem.allocate(1, sizeof(VkPipelineTessellationStateCreateInfo)); + parse_VkPipelineTessellationStateCreateInfo("pTessellationState", obj_pTessellationState, const_cast(*(o.pTessellationState))); + } + } + + { + Json::Value& obj_pViewportState = obj["pViewportState"]; + const int sz = obj_pViewportState.size(); + if (obj_pViewportState.size() == 0) { + (o.pViewportState) = nullptr; + } else { + (o.pViewportState) = (VkPipelineViewportStateCreateInfo*)s_globalMem.allocate(1, sizeof(VkPipelineViewportStateCreateInfo)); + parse_VkPipelineViewportStateCreateInfo("pViewportState", obj_pViewportState, const_cast(*(o.pViewportState))); + } + } + + { + Json::Value& obj_pRasterizationState = obj["pRasterizationState"]; + const int sz = obj_pRasterizationState.size(); + if (obj_pRasterizationState.size() == 0) { + (o.pRasterizationState) = nullptr; + } else { + (o.pRasterizationState) = (VkPipelineRasterizationStateCreateInfo*)s_globalMem.allocate(1, sizeof(VkPipelineRasterizationStateCreateInfo)); + parse_VkPipelineRasterizationStateCreateInfo("pRasterizationState", obj_pRasterizationState, const_cast(*(o.pRasterizationState))); + } + } + + { + Json::Value& obj_pMultisampleState = obj["pMultisampleState"]; + const int sz = obj_pMultisampleState.size(); + if (obj_pMultisampleState.size() == 0) { + (o.pMultisampleState) = nullptr; + } else { + (o.pMultisampleState) = (VkPipelineMultisampleStateCreateInfo*)s_globalMem.allocate(1, sizeof(VkPipelineMultisampleStateCreateInfo)); + parse_VkPipelineMultisampleStateCreateInfo("pMultisampleState", obj_pMultisampleState, const_cast(*(o.pMultisampleState))); + } + } + + { + Json::Value& obj_pDepthStencilState = obj["pDepthStencilState"]; + const int sz = obj_pDepthStencilState.size(); + if (obj_pDepthStencilState.size() == 0) { + (o.pDepthStencilState) = nullptr; + } else { + (o.pDepthStencilState) = (VkPipelineDepthStencilStateCreateInfo*)s_globalMem.allocate(1, sizeof(VkPipelineDepthStencilStateCreateInfo)); + parse_VkPipelineDepthStencilStateCreateInfo("pDepthStencilState", obj_pDepthStencilState, const_cast(*(o.pDepthStencilState))); + } + } + + { + Json::Value& obj_pColorBlendState = obj["pColorBlendState"]; + const int sz = obj_pColorBlendState.size(); + if (obj_pColorBlendState.size() == 0) { + (o.pColorBlendState) = nullptr; + } else { + (o.pColorBlendState) = (VkPipelineColorBlendStateCreateInfo*)s_globalMem.allocate(1, sizeof(VkPipelineColorBlendStateCreateInfo)); + parse_VkPipelineColorBlendStateCreateInfo("pColorBlendState", obj_pColorBlendState, const_cast(*(o.pColorBlendState))); + } + } + + { + Json::Value& obj_pDynamicState = obj["pDynamicState"]; + const int sz = obj_pDynamicState.size(); + if (obj_pDynamicState.size() == 0) { + (o.pDynamicState) = nullptr; + } else { + (o.pDynamicState) = (VkPipelineDynamicStateCreateInfo*)s_globalMem.allocate(1, sizeof(VkPipelineDynamicStateCreateInfo)); + parse_VkPipelineDynamicStateCreateInfo("pDynamicState", obj_pDynamicState, const_cast(*(o.pDynamicState))); + } + } + + + + parse_uint32_t("subpass", obj["subpass"], (o.subpass)); + + + parse_int32_t("basePipelineIndex", obj["basePipelineIndex"], (o.basePipelineIndex)); + +} + +static void parse_VkPushConstantRange(const char* s, Json::Value& obj, VkPushConstantRange& o) { + + parse_VkShaderStageFlags("stageFlags", obj["stageFlags"], (o.stageFlags)); + + parse_uint32_t("offset", obj["offset"], (o.offset)); + + parse_uint32_t("size", obj["size"], (o.size)); + +} + +static void parse_VkPipelineLayoutCreateInfo(const char* s, Json::Value& obj, VkPipelineLayoutCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineLayoutCreateInfo*)parsePNextChain(obj); + + parse_VkPipelineLayoutCreateFlags("flags", obj["flags"], (o.flags)); + + parse_uint32_t("setLayoutCount", obj["setLayoutCount"], (o.setLayoutCount)); + + (o.pSetLayouts) = (VkDescriptorSetLayout*)s_globalMem.allocate((o.setLayoutCount), sizeof(VkDescriptorSetLayout)); + Json::Value& obj_pSetLayouts_arr = obj["pSetLayouts"]; + for (unsigned int i = 0; i < obj_pSetLayouts_arr.size(); i++) { + parse_VkDescriptorSetLayout("pSetLayouts", obj_pSetLayouts_arr[i], const_cast((o.pSetLayouts[i]))); + } + + parse_uint32_t("pushConstantRangeCount", obj["pushConstantRangeCount"], (o.pushConstantRangeCount)); + + (o.pPushConstantRanges) = (VkPushConstantRange*)s_globalMem.allocate((o.pushConstantRangeCount), sizeof(VkPushConstantRange)); + Json::Value& obj_pPushConstantRanges = obj["pPushConstantRanges"]; + if (obj_pPushConstantRanges.size() == 0) (o.pPushConstantRanges) = nullptr; + else { + for (unsigned int i = 0; i < (o.pushConstantRangeCount); i++) { + parse_VkPushConstantRange("pPushConstantRanges", obj_pPushConstantRanges[i], const_cast((o.pPushConstantRanges[i]))); + } + } + +} + +static void parse_VkSamplerCreateInfo(const char* s, Json::Value& obj, VkSamplerCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSamplerCreateInfo*)parsePNextChain(obj); + + parse_VkSamplerCreateFlags("flags", obj["flags"], (o.flags)); + + parse_VkFilter("magFilter", obj["magFilter"], (o.magFilter)); + + parse_VkFilter("minFilter", obj["minFilter"], (o.minFilter)); + + parse_VkSamplerMipmapMode("mipmapMode", obj["mipmapMode"], (o.mipmapMode)); + + parse_VkSamplerAddressMode("addressModeU", obj["addressModeU"], (o.addressModeU)); + + parse_VkSamplerAddressMode("addressModeV", obj["addressModeV"], (o.addressModeV)); + + parse_VkSamplerAddressMode("addressModeW", obj["addressModeW"], (o.addressModeW)); + + parse_float("mipLodBias", obj["mipLodBias"], (o.mipLodBias)); + + parse_VkBool32("anisotropyEnable", obj["anisotropyEnable"], (o.anisotropyEnable)); + + parse_float("maxAnisotropy", obj["maxAnisotropy"], (o.maxAnisotropy)); + + parse_VkBool32("compareEnable", obj["compareEnable"], (o.compareEnable)); + + parse_VkCompareOp("compareOp", obj["compareOp"], (o.compareOp)); + + parse_float("minLod", obj["minLod"], (o.minLod)); + + parse_float("maxLod", obj["maxLod"], (o.maxLod)); + + parse_VkBorderColor("borderColor", obj["borderColor"], (o.borderColor)); + + parse_VkBool32("unnormalizedCoordinates", obj["unnormalizedCoordinates"], (o.unnormalizedCoordinates)); + +} + +static void parse_VkCopyDescriptorSet(const char* s, Json::Value& obj, VkCopyDescriptorSet& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkCopyDescriptorSet*)parsePNextChain(obj); + + + parse_uint32_t("srcBinding", obj["srcBinding"], (o.srcBinding)); + + parse_uint32_t("srcArrayElement", obj["srcArrayElement"], (o.srcArrayElement)); + + + parse_uint32_t("dstBinding", obj["dstBinding"], (o.dstBinding)); + + parse_uint32_t("dstArrayElement", obj["dstArrayElement"], (o.dstArrayElement)); + + parse_uint32_t("descriptorCount", obj["descriptorCount"], (o.descriptorCount)); + +} + +static void parse_VkDescriptorBufferInfo(const char* s, Json::Value& obj, VkDescriptorBufferInfo& o) { + + + parse_VkDeviceSize("offset", obj["offset"], (o.offset)); + + parse_VkDeviceSize("range", obj["range"], (o.range)); + +} + +static void parse_VkDescriptorImageInfo(const char* s, Json::Value& obj, VkDescriptorImageInfo& o) { + + + + parse_VkImageLayout("imageLayout", obj["imageLayout"], (o.imageLayout)); + +} + +static void parse_VkDescriptorPoolSize(const char* s, Json::Value& obj, VkDescriptorPoolSize& o) { + + parse_VkDescriptorType("type", obj["type"], (o.type)); + + parse_uint32_t("descriptorCount", obj["descriptorCount"], (o.descriptorCount)); + +} + +static void parse_VkDescriptorPoolCreateInfo(const char* s, Json::Value& obj, VkDescriptorPoolCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDescriptorPoolCreateInfo*)parsePNextChain(obj); + + parse_VkDescriptorPoolCreateFlags("flags", obj["flags"], (o.flags)); + + parse_uint32_t("maxSets", obj["maxSets"], (o.maxSets)); + + parse_uint32_t("poolSizeCount", obj["poolSizeCount"], (o.poolSizeCount)); + + (o.pPoolSizes) = (VkDescriptorPoolSize*)s_globalMem.allocate((o.poolSizeCount), sizeof(VkDescriptorPoolSize)); + Json::Value& obj_pPoolSizes = obj["pPoolSizes"]; + if (obj_pPoolSizes.size() == 0) (o.pPoolSizes) = nullptr; + else { + for (unsigned int i = 0; i < (o.poolSizeCount); i++) { + parse_VkDescriptorPoolSize("pPoolSizes", obj_pPoolSizes[i], const_cast((o.pPoolSizes[i]))); + } + } + +} + +static void parse_VkDescriptorSetAllocateInfo(const char* s, Json::Value& obj, VkDescriptorSetAllocateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDescriptorSetAllocateInfo*)parsePNextChain(obj); + + + parse_uint32_t("descriptorSetCount", obj["descriptorSetCount"], (o.descriptorSetCount)); + + (o.pSetLayouts) = (VkDescriptorSetLayout*)s_globalMem.allocate((o.descriptorSetCount), sizeof(VkDescriptorSetLayout)); + Json::Value& obj_pSetLayouts_arr = obj["pSetLayouts"]; + for (unsigned int i = 0; i < obj_pSetLayouts_arr.size(); i++) { + parse_VkDescriptorSetLayout("pSetLayouts", obj_pSetLayouts_arr[i], const_cast((o.pSetLayouts[i]))); + } + +} + +static void parse_VkDescriptorSetLayoutBinding(const char* s, Json::Value& obj, VkDescriptorSetLayoutBinding& o) { + + parse_uint32_t("binding", obj["binding"], (o.binding)); + + parse_VkDescriptorType("descriptorType", obj["descriptorType"], (o.descriptorType)); + + parse_uint32_t("descriptorCount", obj["descriptorCount"], (o.descriptorCount)); + + parse_VkShaderStageFlags("stageFlags", obj["stageFlags"], (o.stageFlags)); + + +} + +static void parse_VkDescriptorSetLayoutCreateInfo(const char* s, Json::Value& obj, VkDescriptorSetLayoutCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDescriptorSetLayoutCreateInfo*)parsePNextChain(obj); + + parse_VkDescriptorSetLayoutCreateFlags("flags", obj["flags"], (o.flags)); + + parse_uint32_t("bindingCount", obj["bindingCount"], (o.bindingCount)); + + (o.pBindings) = (VkDescriptorSetLayoutBinding*)s_globalMem.allocate((o.bindingCount), sizeof(VkDescriptorSetLayoutBinding)); + Json::Value& obj_pBindings = obj["pBindings"]; + if (obj_pBindings.size() == 0) (o.pBindings) = nullptr; + else { + for (unsigned int i = 0; i < (o.bindingCount); i++) { + parse_VkDescriptorSetLayoutBinding("pBindings", obj_pBindings[i], const_cast((o.pBindings[i]))); + } + } + +} + +static void parse_VkWriteDescriptorSet(const char* s, Json::Value& obj, VkWriteDescriptorSet& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkWriteDescriptorSet*)parsePNextChain(obj); + + + parse_uint32_t("dstBinding", obj["dstBinding"], (o.dstBinding)); + + parse_uint32_t("dstArrayElement", obj["dstArrayElement"], (o.dstArrayElement)); + + parse_uint32_t("descriptorCount", obj["descriptorCount"], (o.descriptorCount)); + + parse_VkDescriptorType("descriptorType", obj["descriptorType"], (o.descriptorType)); + + (o.pImageInfo) = (VkDescriptorImageInfo*)s_globalMem.allocate((o.descriptorCount), sizeof(VkDescriptorImageInfo)); + Json::Value& obj_pImageInfo = obj["pImageInfo"]; + if (obj_pImageInfo.size() == 0) (o.pImageInfo) = nullptr; + else { + for (unsigned int i = 0; i < (o.descriptorCount); i++) { + parse_VkDescriptorImageInfo("pImageInfo", obj_pImageInfo[i], const_cast((o.pImageInfo[i]))); + } + } + + (o.pBufferInfo) = (VkDescriptorBufferInfo*)s_globalMem.allocate((o.descriptorCount), sizeof(VkDescriptorBufferInfo)); + Json::Value& obj_pBufferInfo = obj["pBufferInfo"]; + if (obj_pBufferInfo.size() == 0) (o.pBufferInfo) = nullptr; + else { + for (unsigned int i = 0; i < (o.descriptorCount); i++) { + parse_VkDescriptorBufferInfo("pBufferInfo", obj_pBufferInfo[i], const_cast((o.pBufferInfo[i]))); + } + } + + (o.pTexelBufferView) = (VkBufferView*)s_globalMem.allocate((o.descriptorCount), sizeof(VkBufferView)); + Json::Value& obj_pTexelBufferView_arr = obj["pTexelBufferView"]; + for (unsigned int i = 0; i < obj_pTexelBufferView_arr.size(); i++) { + parse_VkBufferView("pTexelBufferView", obj_pTexelBufferView_arr[i], const_cast((o.pTexelBufferView[i]))); + } + +} + +static void parse_VkAttachmentDescription(const char* s, Json::Value& obj, VkAttachmentDescription& o) { + + parse_VkAttachmentDescriptionFlags("flags", obj["flags"], (o.flags)); + + parse_VkFormat("format", obj["format"], (o.format)); + + parse_VkSampleCountFlagBits("samples", obj["samples"], (o.samples)); + + parse_VkAttachmentLoadOp("loadOp", obj["loadOp"], (o.loadOp)); + + parse_VkAttachmentStoreOp("storeOp", obj["storeOp"], (o.storeOp)); + + parse_VkAttachmentLoadOp("stencilLoadOp", obj["stencilLoadOp"], (o.stencilLoadOp)); + + parse_VkAttachmentStoreOp("stencilStoreOp", obj["stencilStoreOp"], (o.stencilStoreOp)); + + parse_VkImageLayout("initialLayout", obj["initialLayout"], (o.initialLayout)); + + parse_VkImageLayout("finalLayout", obj["finalLayout"], (o.finalLayout)); + +} + +static void parse_VkAttachmentReference(const char* s, Json::Value& obj, VkAttachmentReference& o) { + + parse_uint32_t("attachment", obj["attachment"], (o.attachment)); + + parse_VkImageLayout("layout", obj["layout"], (o.layout)); + +} + +static void parse_VkFramebufferCreateInfo(const char* s, Json::Value& obj, VkFramebufferCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkFramebufferCreateInfo*)parsePNextChain(obj); + + parse_VkFramebufferCreateFlags("flags", obj["flags"], (o.flags)); + + + parse_uint32_t("attachmentCount", obj["attachmentCount"], (o.attachmentCount)); + + (o.pAttachments) = (VkImageView*)s_globalMem.allocate((o.attachmentCount), sizeof(VkImageView)); + Json::Value& obj_pAttachments_arr = obj["pAttachments"]; + for (unsigned int i = 0; i < obj_pAttachments_arr.size(); i++) { + parse_VkImageView("pAttachments", obj_pAttachments_arr[i], const_cast((o.pAttachments[i]))); + } + + parse_uint32_t("width", obj["width"], (o.width)); + + parse_uint32_t("height", obj["height"], (o.height)); + + parse_uint32_t("layers", obj["layers"], (o.layers)); + +} + +static void parse_VkSubpassDescription(const char* s, Json::Value& obj, VkSubpassDescription& o) { + + parse_VkSubpassDescriptionFlags("flags", obj["flags"], (o.flags)); + + parse_VkPipelineBindPoint("pipelineBindPoint", obj["pipelineBindPoint"], (o.pipelineBindPoint)); + + parse_uint32_t("inputAttachmentCount", obj["inputAttachmentCount"], (o.inputAttachmentCount)); + + (o.pInputAttachments) = (VkAttachmentReference*)s_globalMem.allocate((o.inputAttachmentCount), sizeof(VkAttachmentReference)); + Json::Value& obj_pInputAttachments = obj["pInputAttachments"]; + if (obj_pInputAttachments.size() == 0) (o.pInputAttachments) = nullptr; + else { + for (unsigned int i = 0; i < (o.inputAttachmentCount); i++) { + parse_VkAttachmentReference("pInputAttachments", obj_pInputAttachments[i], const_cast((o.pInputAttachments[i]))); + } + } + + parse_uint32_t("colorAttachmentCount", obj["colorAttachmentCount"], (o.colorAttachmentCount)); + + (o.pColorAttachments) = (VkAttachmentReference*)s_globalMem.allocate((o.colorAttachmentCount), sizeof(VkAttachmentReference)); + Json::Value& obj_pColorAttachments = obj["pColorAttachments"]; + if (obj_pColorAttachments.size() == 0) (o.pColorAttachments) = nullptr; + else { + for (unsigned int i = 0; i < (o.colorAttachmentCount); i++) { + parse_VkAttachmentReference("pColorAttachments", obj_pColorAttachments[i], const_cast((o.pColorAttachments[i]))); + } + } + + (o.pResolveAttachments) = (VkAttachmentReference*)s_globalMem.allocate((o.colorAttachmentCount), sizeof(VkAttachmentReference)); + Json::Value& obj_pResolveAttachments = obj["pResolveAttachments"]; + if (obj_pResolveAttachments.size() == 0) (o.pResolveAttachments) = nullptr; + else { + for (unsigned int i = 0; i < (o.colorAttachmentCount); i++) { + parse_VkAttachmentReference("pResolveAttachments", obj_pResolveAttachments[i], const_cast((o.pResolveAttachments[i]))); + } + } + + { + Json::Value& obj_pDepthStencilAttachment = obj["pDepthStencilAttachment"]; + const int sz = obj_pDepthStencilAttachment.size(); + if (obj_pDepthStencilAttachment.size() == 0) { + (o.pDepthStencilAttachment) = nullptr; + } else { + (o.pDepthStencilAttachment) = (VkAttachmentReference*)s_globalMem.allocate(1, sizeof(VkAttachmentReference)); + parse_VkAttachmentReference("pDepthStencilAttachment", obj_pDepthStencilAttachment, const_cast(*(o.pDepthStencilAttachment))); + } + } + + parse_uint32_t("preserveAttachmentCount", obj["preserveAttachmentCount"], (o.preserveAttachmentCount)); + + (o.pPreserveAttachments) = (uint32_t*)s_globalMem.allocate((o.preserveAttachmentCount), sizeof(uint32_t)); + Json::Value& obj_pPreserveAttachments_arr = obj["pPreserveAttachments"]; + for (unsigned int i = 0; i < obj_pPreserveAttachments_arr.size(); i++) { + parse_uint32_t("pPreserveAttachments", obj_pPreserveAttachments_arr[i], const_cast((o.pPreserveAttachments[i]))); + } + +} + +static void parse_VkSubpassDependency(const char* s, Json::Value& obj, VkSubpassDependency& o) { + + parse_uint32_t("srcSubpass", obj["srcSubpass"], (o.srcSubpass)); + + parse_uint32_t("dstSubpass", obj["dstSubpass"], (o.dstSubpass)); + + parse_VkPipelineStageFlags("srcStageMask", obj["srcStageMask"], (o.srcStageMask)); + + parse_VkPipelineStageFlags("dstStageMask", obj["dstStageMask"], (o.dstStageMask)); + + parse_VkAccessFlags("srcAccessMask", obj["srcAccessMask"], (o.srcAccessMask)); + + parse_VkAccessFlags("dstAccessMask", obj["dstAccessMask"], (o.dstAccessMask)); + + parse_VkDependencyFlags("dependencyFlags", obj["dependencyFlags"], (o.dependencyFlags)); + +} + +static void parse_VkRenderPassCreateInfo(const char* s, Json::Value& obj, VkRenderPassCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkRenderPassCreateInfo*)parsePNextChain(obj); + + parse_VkRenderPassCreateFlags("flags", obj["flags"], (o.flags)); + + parse_uint32_t("attachmentCount", obj["attachmentCount"], (o.attachmentCount)); + + (o.pAttachments) = (VkAttachmentDescription*)s_globalMem.allocate((o.attachmentCount), sizeof(VkAttachmentDescription)); + Json::Value& obj_pAttachments = obj["pAttachments"]; + if (obj_pAttachments.size() == 0) (o.pAttachments) = nullptr; + else { + for (unsigned int i = 0; i < (o.attachmentCount); i++) { + parse_VkAttachmentDescription("pAttachments", obj_pAttachments[i], const_cast((o.pAttachments[i]))); + } + } + + parse_uint32_t("subpassCount", obj["subpassCount"], (o.subpassCount)); + + (o.pSubpasses) = (VkSubpassDescription*)s_globalMem.allocate((o.subpassCount), sizeof(VkSubpassDescription)); + Json::Value& obj_pSubpasses = obj["pSubpasses"]; + if (obj_pSubpasses.size() == 0) (o.pSubpasses) = nullptr; + else { + for (unsigned int i = 0; i < (o.subpassCount); i++) { + parse_VkSubpassDescription("pSubpasses", obj_pSubpasses[i], const_cast((o.pSubpasses[i]))); + } + } + + parse_uint32_t("dependencyCount", obj["dependencyCount"], (o.dependencyCount)); + + (o.pDependencies) = (VkSubpassDependency*)s_globalMem.allocate((o.dependencyCount), sizeof(VkSubpassDependency)); + Json::Value& obj_pDependencies = obj["pDependencies"]; + if (obj_pDependencies.size() == 0) (o.pDependencies) = nullptr; + else { + for (unsigned int i = 0; i < (o.dependencyCount); i++) { + parse_VkSubpassDependency("pDependencies", obj_pDependencies[i], const_cast((o.pDependencies[i]))); + } + } + +} + +static void parse_VkCommandPoolCreateInfo(const char* s, Json::Value& obj, VkCommandPoolCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkCommandPoolCreateInfo*)parsePNextChain(obj); + + parse_VkCommandPoolCreateFlags("flags", obj["flags"], (o.flags)); + + parse_uint32_t("queueFamilyIndex", obj["queueFamilyIndex"], (o.queueFamilyIndex)); + +} + +static void parse_VkCommandBufferAllocateInfo(const char* s, Json::Value& obj, VkCommandBufferAllocateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkCommandBufferAllocateInfo*)parsePNextChain(obj); + + + parse_VkCommandBufferLevel("level", obj["level"], (o.level)); + + parse_uint32_t("commandBufferCount", obj["commandBufferCount"], (o.commandBufferCount)); + +} + +static void parse_VkCommandBufferInheritanceInfo(const char* s, Json::Value& obj, VkCommandBufferInheritanceInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkCommandBufferInheritanceInfo*)parsePNextChain(obj); + + + parse_uint32_t("subpass", obj["subpass"], (o.subpass)); + + + parse_VkBool32("occlusionQueryEnable", obj["occlusionQueryEnable"], (o.occlusionQueryEnable)); + + parse_VkQueryControlFlags("queryFlags", obj["queryFlags"], (o.queryFlags)); + + parse_VkQueryPipelineStatisticFlags("pipelineStatistics", obj["pipelineStatistics"], (o.pipelineStatistics)); + +} + +static void parse_VkCommandBufferBeginInfo(const char* s, Json::Value& obj, VkCommandBufferBeginInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkCommandBufferBeginInfo*)parsePNextChain(obj); + + parse_VkCommandBufferUsageFlags("flags", obj["flags"], (o.flags)); + + { + Json::Value& obj_pInheritanceInfo = obj["pInheritanceInfo"]; + const int sz = obj_pInheritanceInfo.size(); + if (obj_pInheritanceInfo.size() == 0) { + (o.pInheritanceInfo) = nullptr; + } else { + (o.pInheritanceInfo) = (VkCommandBufferInheritanceInfo*)s_globalMem.allocate(1, sizeof(VkCommandBufferInheritanceInfo)); + parse_VkCommandBufferInheritanceInfo("pInheritanceInfo", obj_pInheritanceInfo, const_cast(*(o.pInheritanceInfo))); + } + } + +} + +static void parse_VkBufferCopy(const char* s, Json::Value& obj, VkBufferCopy& o) { + + parse_VkDeviceSize("srcOffset", obj["srcOffset"], (o.srcOffset)); + + parse_VkDeviceSize("dstOffset", obj["dstOffset"], (o.dstOffset)); + + parse_VkDeviceSize("size", obj["size"], (o.size)); + +} + +static void parse_VkImageSubresourceLayers(const char* s, Json::Value& obj, VkImageSubresourceLayers& o) { + + parse_VkImageAspectFlags("aspectMask", obj["aspectMask"], (o.aspectMask)); + + parse_uint32_t("mipLevel", obj["mipLevel"], (o.mipLevel)); + + parse_uint32_t("baseArrayLayer", obj["baseArrayLayer"], (o.baseArrayLayer)); + + parse_uint32_t("layerCount", obj["layerCount"], (o.layerCount)); + +} + +static void parse_VkBufferImageCopy(const char* s, Json::Value& obj, VkBufferImageCopy& o) { + + parse_VkDeviceSize("bufferOffset", obj["bufferOffset"], (o.bufferOffset)); + + parse_uint32_t("bufferRowLength", obj["bufferRowLength"], (o.bufferRowLength)); + + parse_uint32_t("bufferImageHeight", obj["bufferImageHeight"], (o.bufferImageHeight)); + + parse_VkImageSubresourceLayers("imageSubresource", obj["imageSubresource"], (o.imageSubresource)); + + parse_VkOffset3D("imageOffset", obj["imageOffset"], (o.imageOffset)); + + parse_VkExtent3D("imageExtent", obj["imageExtent"], (o.imageExtent)); + +} + +static void parse_VkClearColorValue(const char* s, Json::Value& obj, VkClearColorValue& o) { + + Json::Value& obj_float32_arr = obj["float32"]; + for (unsigned int i = 0; i < obj_float32_arr.size(); i++) { + parse_float("float32", obj_float32_arr[i], const_cast((o.float32[i]))); + } + + Json::Value& obj_int32_arr = obj["int32"]; + for (unsigned int i = 0; i < obj_int32_arr.size(); i++) { + parse_int32_t("int32", obj_int32_arr[i], const_cast((o.int32[i]))); + } + + Json::Value& obj_uint32_arr = obj["uint32"]; + for (unsigned int i = 0; i < obj_uint32_arr.size(); i++) { + parse_uint32_t("uint32", obj_uint32_arr[i], const_cast((o.uint32[i]))); + } + +} + +static void parse_VkClearDepthStencilValue(const char* s, Json::Value& obj, VkClearDepthStencilValue& o) { + + parse_float("depth", obj["depth"], (o.depth)); + + parse_uint32_t("stencil", obj["stencil"], (o.stencil)); + +} + +static void parse_VkClearValue(const char* s, Json::Value& obj, VkClearValue& o) { + + parse_VkClearColorValue("color", obj["color"], (o.color)); + + parse_VkClearDepthStencilValue("depthStencil", obj["depthStencil"], (o.depthStencil)); + +} + +static void parse_VkClearAttachment(const char* s, Json::Value& obj, VkClearAttachment& o) { + + parse_VkImageAspectFlags("aspectMask", obj["aspectMask"], (o.aspectMask)); + + parse_uint32_t("colorAttachment", obj["colorAttachment"], (o.colorAttachment)); + + parse_VkClearValue("clearValue", obj["clearValue"], (o.clearValue)); + +} + +static void parse_VkClearRect(const char* s, Json::Value& obj, VkClearRect& o) { + + parse_VkRect2D("rect", obj["rect"], (o.rect)); + + parse_uint32_t("baseArrayLayer", obj["baseArrayLayer"], (o.baseArrayLayer)); + + parse_uint32_t("layerCount", obj["layerCount"], (o.layerCount)); + +} + +static void parse_VkImageBlit(const char* s, Json::Value& obj, VkImageBlit& o) { + + parse_VkImageSubresourceLayers("srcSubresource", obj["srcSubresource"], (o.srcSubresource)); + + Json::Value& obj_srcOffsets_arr = obj["srcOffsets"]; + for (unsigned int i = 0; i < obj_srcOffsets_arr.size(); i++) { + parse_VkOffset3D("srcOffsets", obj_srcOffsets_arr[i], const_cast((o.srcOffsets[i]))); + } + + parse_VkImageSubresourceLayers("dstSubresource", obj["dstSubresource"], (o.dstSubresource)); + + Json::Value& obj_dstOffsets_arr = obj["dstOffsets"]; + for (unsigned int i = 0; i < obj_dstOffsets_arr.size(); i++) { + parse_VkOffset3D("dstOffsets", obj_dstOffsets_arr[i], const_cast((o.dstOffsets[i]))); + } + +} + +static void parse_VkImageCopy(const char* s, Json::Value& obj, VkImageCopy& o) { + + parse_VkImageSubresourceLayers("srcSubresource", obj["srcSubresource"], (o.srcSubresource)); + + parse_VkOffset3D("srcOffset", obj["srcOffset"], (o.srcOffset)); + + parse_VkImageSubresourceLayers("dstSubresource", obj["dstSubresource"], (o.dstSubresource)); + + parse_VkOffset3D("dstOffset", obj["dstOffset"], (o.dstOffset)); + + parse_VkExtent3D("extent", obj["extent"], (o.extent)); + +} + +static void parse_VkImageResolve(const char* s, Json::Value& obj, VkImageResolve& o) { + + parse_VkImageSubresourceLayers("srcSubresource", obj["srcSubresource"], (o.srcSubresource)); + + parse_VkOffset3D("srcOffset", obj["srcOffset"], (o.srcOffset)); + + parse_VkImageSubresourceLayers("dstSubresource", obj["dstSubresource"], (o.dstSubresource)); + + parse_VkOffset3D("dstOffset", obj["dstOffset"], (o.dstOffset)); + + parse_VkExtent3D("extent", obj["extent"], (o.extent)); + +} + +static void parse_VkRenderPassBeginInfo(const char* s, Json::Value& obj, VkRenderPassBeginInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkRenderPassBeginInfo*)parsePNextChain(obj); + + + + parse_VkRect2D("renderArea", obj["renderArea"], (o.renderArea)); + + parse_uint32_t("clearValueCount", obj["clearValueCount"], (o.clearValueCount)); + + (o.pClearValues) = (VkClearValue*)s_globalMem.allocate((o.clearValueCount), sizeof(VkClearValue)); + Json::Value& obj_pClearValues_arr = obj["pClearValues"]; + for (unsigned int i = 0; i < obj_pClearValues_arr.size(); i++) { + parse_VkClearValue("pClearValues", obj_pClearValues_arr[i], const_cast((o.pClearValues[i]))); + } + +} + +#ifdef VK_VERSION_1_1 +static void parse_VkSamplerYcbcrConversion(const char* s, Json::Value& obj, VkSamplerYcbcrConversion& o) { +// std::string _res = obj.asString(); +} +#endif + +#ifdef VK_VERSION_1_1 +static std::map VkSubgroupFeatureFlagBits_map = { + std::make_pair("VK_SUBGROUP_FEATURE_BASIC_BIT", 1UL << 0), + std::make_pair("VK_SUBGROUP_FEATURE_VOTE_BIT", 1UL << 1), + std::make_pair("VK_SUBGROUP_FEATURE_ARITHMETIC_BIT", 1UL << 2), + std::make_pair("VK_SUBGROUP_FEATURE_BALLOT_BIT", 1UL << 3), + std::make_pair("VK_SUBGROUP_FEATURE_SHUFFLE_BIT", 1UL << 4), + std::make_pair("VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT", 1UL << 5), + std::make_pair("VK_SUBGROUP_FEATURE_CLUSTERED_BIT", 1UL << 6), + std::make_pair("VK_SUBGROUP_FEATURE_QUAD_BIT", 1UL << 7), + std::make_pair("VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV", 1UL << 8), +}; +static void parse_VkSubgroupFeatureFlagBits(const char* s, Json::Value& obj, VkSubgroupFeatureFlagBits& o) { + std::string _res = obj.asString(); + o = (VkSubgroupFeatureFlagBits)VkSubgroupFeatureFlagBits_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_1 +static std::map VkPeerMemoryFeatureFlagBits_map = { + std::make_pair("VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT", 1UL << 0), + std::make_pair("VK_PEER_MEMORY_FEATURE_COPY_DST_BIT", 1UL << 1), + std::make_pair("VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT", 1UL << 2), + std::make_pair("VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT", 1UL << 3), +}; +static void parse_VkPeerMemoryFeatureFlagBits(const char* s, Json::Value& obj, VkPeerMemoryFeatureFlagBits& o) { + std::string _res = obj.asString(); + o = (VkPeerMemoryFeatureFlagBits)VkPeerMemoryFeatureFlagBits_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_1 +static std::map VkMemoryAllocateFlagBits_map = { + std::make_pair("VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT", 1UL << 0), + std::make_pair("VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT", 1UL << 1), + std::make_pair("VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT", 1UL << 2), +}; +static void parse_VkMemoryAllocateFlagBits(const char* s, Json::Value& obj, VkMemoryAllocateFlagBits& o) { + std::string _res = obj.asString(); + o = (VkMemoryAllocateFlagBits)VkMemoryAllocateFlagBits_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_1 +static std::map VkPointClippingBehavior_map = { + std::make_pair("VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES", 0), + std::make_pair("VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY", 1), +}; +static void parse_VkPointClippingBehavior(const char* s, Json::Value& obj, VkPointClippingBehavior& o) { + std::string _res = obj.asString(); + o = (VkPointClippingBehavior)VkPointClippingBehavior_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_1 +static std::map VkTessellationDomainOrigin_map = { + std::make_pair("VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT", 0), + std::make_pair("VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT", 1), +}; +static void parse_VkTessellationDomainOrigin(const char* s, Json::Value& obj, VkTessellationDomainOrigin& o) { + std::string _res = obj.asString(); + o = (VkTessellationDomainOrigin)VkTessellationDomainOrigin_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_1 +static std::map VkSamplerYcbcrModelConversion_map = { + std::make_pair("VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY", 0), + std::make_pair("VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY", 1), + std::make_pair("VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709", 2), + std::make_pair("VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601", 3), + std::make_pair("VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020", 4), +}; +static void parse_VkSamplerYcbcrModelConversion(const char* s, Json::Value& obj, VkSamplerYcbcrModelConversion& o) { + std::string _res = obj.asString(); + o = (VkSamplerYcbcrModelConversion)VkSamplerYcbcrModelConversion_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_1 +static std::map VkSamplerYcbcrRange_map = { + std::make_pair("VK_SAMPLER_YCBCR_RANGE_ITU_FULL", 0), + std::make_pair("VK_SAMPLER_YCBCR_RANGE_ITU_NARROW", 1), +}; +static void parse_VkSamplerYcbcrRange(const char* s, Json::Value& obj, VkSamplerYcbcrRange& o) { + std::string _res = obj.asString(); + o = (VkSamplerYcbcrRange)VkSamplerYcbcrRange_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_1 +static std::map VkChromaLocation_map = { + std::make_pair("VK_CHROMA_LOCATION_COSITED_EVEN", 0), + std::make_pair("VK_CHROMA_LOCATION_MIDPOINT", 1), +}; +static void parse_VkChromaLocation(const char* s, Json::Value& obj, VkChromaLocation& o) { + std::string _res = obj.asString(); + o = (VkChromaLocation)VkChromaLocation_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_1 +static std::map VkExternalMemoryHandleTypeFlagBits_map = { + std::make_pair("VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT", 1UL << 0), + std::make_pair("VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT", 1UL << 1), + std::make_pair("VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT", 1UL << 2), + std::make_pair("VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT", 1UL << 3), + std::make_pair("VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT", 1UL << 4), + std::make_pair("VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT", 1UL << 5), + std::make_pair("VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT", 1UL << 6), + std::make_pair("VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT", 1UL << 9), + std::make_pair("VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID", 1UL << 10), + std::make_pair("VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT", 1UL << 7), + std::make_pair("VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT", 1UL << 8), + std::make_pair("VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA", 1UL << 11), + std::make_pair("VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV", 1UL << 12), + std::make_pair("VK_EXTERNAL_MEMORY_HANDLE_TYPE_RESERVED_13_BIT_NV", 1UL << 13), +}; +static void parse_VkExternalMemoryHandleTypeFlagBits(const char* s, Json::Value& obj, VkExternalMemoryHandleTypeFlagBits& o) { + std::string _res = obj.asString(); + o = (VkExternalMemoryHandleTypeFlagBits)VkExternalMemoryHandleTypeFlagBits_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_1 +static std::map VkExternalMemoryFeatureFlagBits_map = { + std::make_pair("VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT", 1UL << 0), + std::make_pair("VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT", 1UL << 1), + std::make_pair("VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT", 1UL << 2), +}; +static void parse_VkExternalMemoryFeatureFlagBits(const char* s, Json::Value& obj, VkExternalMemoryFeatureFlagBits& o) { + std::string _res = obj.asString(); + o = (VkExternalMemoryFeatureFlagBits)VkExternalMemoryFeatureFlagBits_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_1 +static std::map VkExternalFenceHandleTypeFlagBits_map = { + std::make_pair("VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT", 1UL << 0), + std::make_pair("VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT", 1UL << 1), + std::make_pair("VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT", 1UL << 2), + std::make_pair("VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT", 1UL << 3), + std::make_pair("VK_EXTERNAL_FENCE_HANDLE_TYPE_RESERVED_4_BIT_NV", 1UL << 4), + std::make_pair("VK_EXTERNAL_FENCE_HANDLE_TYPE_RESERVED_5_BIT_NV", 1UL << 5), +}; +static void parse_VkExternalFenceHandleTypeFlagBits(const char* s, Json::Value& obj, VkExternalFenceHandleTypeFlagBits& o) { + std::string _res = obj.asString(); + o = (VkExternalFenceHandleTypeFlagBits)VkExternalFenceHandleTypeFlagBits_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_1 +static std::map VkExternalFenceFeatureFlagBits_map = { + std::make_pair("VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT", 1UL << 0), + std::make_pair("VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT", 1UL << 1), +}; +static void parse_VkExternalFenceFeatureFlagBits(const char* s, Json::Value& obj, VkExternalFenceFeatureFlagBits& o) { + std::string _res = obj.asString(); + o = (VkExternalFenceFeatureFlagBits)VkExternalFenceFeatureFlagBits_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_1 +static std::map VkFenceImportFlagBits_map = { + std::make_pair("VK_FENCE_IMPORT_TEMPORARY_BIT", 1UL << 0), +}; +static void parse_VkFenceImportFlagBits(const char* s, Json::Value& obj, VkFenceImportFlagBits& o) { + std::string _res = obj.asString(); + o = (VkFenceImportFlagBits)VkFenceImportFlagBits_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_1 +static std::map VkSemaphoreImportFlagBits_map = { + std::make_pair("VK_SEMAPHORE_IMPORT_TEMPORARY_BIT", 1UL << 0), +}; +static void parse_VkSemaphoreImportFlagBits(const char* s, Json::Value& obj, VkSemaphoreImportFlagBits& o) { + std::string _res = obj.asString(); + o = (VkSemaphoreImportFlagBits)VkSemaphoreImportFlagBits_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_1 +static std::map VkExternalSemaphoreHandleTypeFlagBits_map = { + std::make_pair("VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT", 1UL << 0), + std::make_pair("VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT", 1UL << 1), + std::make_pair("VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT", 1UL << 2), + std::make_pair("VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT", 1UL << 3), + std::make_pair("VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT", 1UL << 4), + std::make_pair("VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA", 1UL << 7), + std::make_pair("VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_RESERVED_5_BIT_NV", 1UL << 5), + std::make_pair("VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_RESERVED_6_BIT_NV", 1UL << 6), +}; +static void parse_VkExternalSemaphoreHandleTypeFlagBits(const char* s, Json::Value& obj, VkExternalSemaphoreHandleTypeFlagBits& o) { + std::string _res = obj.asString(); + o = (VkExternalSemaphoreHandleTypeFlagBits)VkExternalSemaphoreHandleTypeFlagBits_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_1 +static std::map VkExternalSemaphoreFeatureFlagBits_map = { + std::make_pair("VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT", 1UL << 0), + std::make_pair("VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT", 1UL << 1), +}; +static void parse_VkExternalSemaphoreFeatureFlagBits(const char* s, Json::Value& obj, VkExternalSemaphoreFeatureFlagBits& o) { + std::string _res = obj.asString(); + o = (VkExternalSemaphoreFeatureFlagBits)VkExternalSemaphoreFeatureFlagBits_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkSubgroupFeatureFlags(const char* s, Json::Value& obj, VkSubgroupFeatureFlags& o) { + o = (VkSubgroupFeatureFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkSubgroupFeatureFlagBits)VkSubgroupFeatureFlagBits_map[it]; + } +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPeerMemoryFeatureFlags(const char* s, Json::Value& obj, VkPeerMemoryFeatureFlags& o) { + o = (VkPeerMemoryFeatureFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkPeerMemoryFeatureFlagBits)VkPeerMemoryFeatureFlagBits_map[it]; + } +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkMemoryAllocateFlags(const char* s, Json::Value& obj, VkMemoryAllocateFlags& o) { + o = (VkMemoryAllocateFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkMemoryAllocateFlagBits)VkMemoryAllocateFlagBits_map[it]; + } +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkExternalMemoryHandleTypeFlags(const char* s, Json::Value& obj, VkExternalMemoryHandleTypeFlags& o) { + o = (VkExternalMemoryHandleTypeFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkExternalMemoryHandleTypeFlagBits)VkExternalMemoryHandleTypeFlagBits_map[it]; + } +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkExternalMemoryFeatureFlags(const char* s, Json::Value& obj, VkExternalMemoryFeatureFlags& o) { + o = (VkExternalMemoryFeatureFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkExternalMemoryFeatureFlagBits)VkExternalMemoryFeatureFlagBits_map[it]; + } +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkExternalFenceHandleTypeFlags(const char* s, Json::Value& obj, VkExternalFenceHandleTypeFlags& o) { + o = (VkExternalFenceHandleTypeFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkExternalFenceHandleTypeFlagBits)VkExternalFenceHandleTypeFlagBits_map[it]; + } +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkExternalFenceFeatureFlags(const char* s, Json::Value& obj, VkExternalFenceFeatureFlags& o) { + o = (VkExternalFenceFeatureFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkExternalFenceFeatureFlagBits)VkExternalFenceFeatureFlagBits_map[it]; + } +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkFenceImportFlags(const char* s, Json::Value& obj, VkFenceImportFlags& o) { + o = (VkFenceImportFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkFenceImportFlagBits)VkFenceImportFlagBits_map[it]; + } +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkSemaphoreImportFlags(const char* s, Json::Value& obj, VkSemaphoreImportFlags& o) { + o = (VkSemaphoreImportFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkSemaphoreImportFlagBits)VkSemaphoreImportFlagBits_map[it]; + } +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkExternalSemaphoreHandleTypeFlags(const char* s, Json::Value& obj, VkExternalSemaphoreHandleTypeFlags& o) { + o = (VkExternalSemaphoreHandleTypeFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkExternalSemaphoreHandleTypeFlagBits)VkExternalSemaphoreHandleTypeFlagBits_map[it]; + } +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkExternalSemaphoreFeatureFlags(const char* s, Json::Value& obj, VkExternalSemaphoreFeatureFlags& o) { + o = (VkExternalSemaphoreFeatureFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkExternalSemaphoreFeatureFlagBits)VkExternalSemaphoreFeatureFlagBits_map[it]; + } +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceSubgroupProperties(const char* s, Json::Value& obj, VkPhysicalDeviceSubgroupProperties& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceSubgroupProperties*)parsePNextChain(obj); + + parse_uint32_t("subgroupSize", obj["subgroupSize"], (o.subgroupSize)); + + parse_VkShaderStageFlags("supportedStages", obj["supportedStages"], (o.supportedStages)); + + parse_VkSubgroupFeatureFlags("supportedOperations", obj["supportedOperations"], (o.supportedOperations)); + + parse_VkBool32("quadOperationsInAllStages", obj["quadOperationsInAllStages"], (o.quadOperationsInAllStages)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkBindBufferMemoryInfo(const char* s, Json::Value& obj, VkBindBufferMemoryInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkBindBufferMemoryInfo*)parsePNextChain(obj); + + + + parse_VkDeviceSize("memoryOffset", obj["memoryOffset"], (o.memoryOffset)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkBindImageMemoryInfo(const char* s, Json::Value& obj, VkBindImageMemoryInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkBindImageMemoryInfo*)parsePNextChain(obj); + + + + parse_VkDeviceSize("memoryOffset", obj["memoryOffset"], (o.memoryOffset)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDevice16BitStorageFeatures(const char* s, Json::Value& obj, VkPhysicalDevice16BitStorageFeatures& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDevice16BitStorageFeatures*)parsePNextChain(obj); + + parse_VkBool32("storageBuffer16BitAccess", obj["storageBuffer16BitAccess"], (o.storageBuffer16BitAccess)); + + parse_VkBool32("uniformAndStorageBuffer16BitAccess", obj["uniformAndStorageBuffer16BitAccess"], (o.uniformAndStorageBuffer16BitAccess)); + + parse_VkBool32("storagePushConstant16", obj["storagePushConstant16"], (o.storagePushConstant16)); + + parse_VkBool32("storageInputOutput16", obj["storageInputOutput16"], (o.storageInputOutput16)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkMemoryDedicatedRequirements(const char* s, Json::Value& obj, VkMemoryDedicatedRequirements& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkMemoryDedicatedRequirements*)parsePNextChain(obj); + + parse_VkBool32("prefersDedicatedAllocation", obj["prefersDedicatedAllocation"], (o.prefersDedicatedAllocation)); + + parse_VkBool32("requiresDedicatedAllocation", obj["requiresDedicatedAllocation"], (o.requiresDedicatedAllocation)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkMemoryDedicatedAllocateInfo(const char* s, Json::Value& obj, VkMemoryDedicatedAllocateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkMemoryDedicatedAllocateInfo*)parsePNextChain(obj); + + + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkMemoryAllocateFlagsInfo(const char* s, Json::Value& obj, VkMemoryAllocateFlagsInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkMemoryAllocateFlagsInfo*)parsePNextChain(obj); + + parse_VkMemoryAllocateFlags("flags", obj["flags"], (o.flags)); + + parse_uint32_t("deviceMask", obj["deviceMask"], (o.deviceMask)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkDeviceGroupRenderPassBeginInfo(const char* s, Json::Value& obj, VkDeviceGroupRenderPassBeginInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDeviceGroupRenderPassBeginInfo*)parsePNextChain(obj); + + parse_uint32_t("deviceMask", obj["deviceMask"], (o.deviceMask)); + + parse_uint32_t("deviceRenderAreaCount", obj["deviceRenderAreaCount"], (o.deviceRenderAreaCount)); + + (o.pDeviceRenderAreas) = (VkRect2D*)s_globalMem.allocate((o.deviceRenderAreaCount), sizeof(VkRect2D)); + Json::Value& obj_pDeviceRenderAreas = obj["pDeviceRenderAreas"]; + if (obj_pDeviceRenderAreas.size() == 0) (o.pDeviceRenderAreas) = nullptr; + else { + for (unsigned int i = 0; i < (o.deviceRenderAreaCount); i++) { + parse_VkRect2D("pDeviceRenderAreas", obj_pDeviceRenderAreas[i], const_cast((o.pDeviceRenderAreas[i]))); + } + } + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkDeviceGroupCommandBufferBeginInfo(const char* s, Json::Value& obj, VkDeviceGroupCommandBufferBeginInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDeviceGroupCommandBufferBeginInfo*)parsePNextChain(obj); + + parse_uint32_t("deviceMask", obj["deviceMask"], (o.deviceMask)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkDeviceGroupSubmitInfo(const char* s, Json::Value& obj, VkDeviceGroupSubmitInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDeviceGroupSubmitInfo*)parsePNextChain(obj); + + parse_uint32_t("waitSemaphoreCount", obj["waitSemaphoreCount"], (o.waitSemaphoreCount)); + + (o.pWaitSemaphoreDeviceIndices) = (uint32_t*)s_globalMem.allocate((o.waitSemaphoreCount), sizeof(uint32_t)); + Json::Value& obj_pWaitSemaphoreDeviceIndices_arr = obj["pWaitSemaphoreDeviceIndices"]; + for (unsigned int i = 0; i < obj_pWaitSemaphoreDeviceIndices_arr.size(); i++) { + parse_uint32_t("pWaitSemaphoreDeviceIndices", obj_pWaitSemaphoreDeviceIndices_arr[i], const_cast((o.pWaitSemaphoreDeviceIndices[i]))); + } + + parse_uint32_t("commandBufferCount", obj["commandBufferCount"], (o.commandBufferCount)); + + (o.pCommandBufferDeviceMasks) = (uint32_t*)s_globalMem.allocate((o.commandBufferCount), sizeof(uint32_t)); + Json::Value& obj_pCommandBufferDeviceMasks_arr = obj["pCommandBufferDeviceMasks"]; + for (unsigned int i = 0; i < obj_pCommandBufferDeviceMasks_arr.size(); i++) { + parse_uint32_t("pCommandBufferDeviceMasks", obj_pCommandBufferDeviceMasks_arr[i], const_cast((o.pCommandBufferDeviceMasks[i]))); + } + + parse_uint32_t("signalSemaphoreCount", obj["signalSemaphoreCount"], (o.signalSemaphoreCount)); + + (o.pSignalSemaphoreDeviceIndices) = (uint32_t*)s_globalMem.allocate((o.signalSemaphoreCount), sizeof(uint32_t)); + Json::Value& obj_pSignalSemaphoreDeviceIndices_arr = obj["pSignalSemaphoreDeviceIndices"]; + for (unsigned int i = 0; i < obj_pSignalSemaphoreDeviceIndices_arr.size(); i++) { + parse_uint32_t("pSignalSemaphoreDeviceIndices", obj_pSignalSemaphoreDeviceIndices_arr[i], const_cast((o.pSignalSemaphoreDeviceIndices[i]))); + } + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkBindBufferMemoryDeviceGroupInfo(const char* s, Json::Value& obj, VkBindBufferMemoryDeviceGroupInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkBindBufferMemoryDeviceGroupInfo*)parsePNextChain(obj); + + parse_uint32_t("deviceIndexCount", obj["deviceIndexCount"], (o.deviceIndexCount)); + + (o.pDeviceIndices) = (uint32_t*)s_globalMem.allocate((o.deviceIndexCount), sizeof(uint32_t)); + Json::Value& obj_pDeviceIndices_arr = obj["pDeviceIndices"]; + for (unsigned int i = 0; i < obj_pDeviceIndices_arr.size(); i++) { + parse_uint32_t("pDeviceIndices", obj_pDeviceIndices_arr[i], const_cast((o.pDeviceIndices[i]))); + } + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkBindImageMemoryDeviceGroupInfo(const char* s, Json::Value& obj, VkBindImageMemoryDeviceGroupInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkBindImageMemoryDeviceGroupInfo*)parsePNextChain(obj); + + parse_uint32_t("deviceIndexCount", obj["deviceIndexCount"], (o.deviceIndexCount)); + + (o.pDeviceIndices) = (uint32_t*)s_globalMem.allocate((o.deviceIndexCount), sizeof(uint32_t)); + Json::Value& obj_pDeviceIndices_arr = obj["pDeviceIndices"]; + for (unsigned int i = 0; i < obj_pDeviceIndices_arr.size(); i++) { + parse_uint32_t("pDeviceIndices", obj_pDeviceIndices_arr[i], const_cast((o.pDeviceIndices[i]))); + } + + parse_uint32_t("splitInstanceBindRegionCount", obj["splitInstanceBindRegionCount"], (o.splitInstanceBindRegionCount)); + + (o.pSplitInstanceBindRegions) = (VkRect2D*)s_globalMem.allocate((o.splitInstanceBindRegionCount), sizeof(VkRect2D)); + Json::Value& obj_pSplitInstanceBindRegions = obj["pSplitInstanceBindRegions"]; + if (obj_pSplitInstanceBindRegions.size() == 0) (o.pSplitInstanceBindRegions) = nullptr; + else { + for (unsigned int i = 0; i < (o.splitInstanceBindRegionCount); i++) { + parse_VkRect2D("pSplitInstanceBindRegions", obj_pSplitInstanceBindRegions[i], const_cast((o.pSplitInstanceBindRegions[i]))); + } + } + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceGroupProperties(const char* s, Json::Value& obj, VkPhysicalDeviceGroupProperties& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceGroupProperties*)parsePNextChain(obj); + + parse_uint32_t("physicalDeviceCount", obj["physicalDeviceCount"], (o.physicalDeviceCount)); + + Json::Value& obj_physicalDevices_arr = obj["physicalDevices"]; + for (unsigned int i = 0; i < obj_physicalDevices_arr.size(); i++) { + parse_VkPhysicalDevice("physicalDevices", obj_physicalDevices_arr[i], const_cast((o.physicalDevices[i]))); + } + + parse_VkBool32("subsetAllocation", obj["subsetAllocation"], (o.subsetAllocation)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkDeviceGroupDeviceCreateInfo(const char* s, Json::Value& obj, VkDeviceGroupDeviceCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDeviceGroupDeviceCreateInfo*)parsePNextChain(obj); + + parse_uint32_t("physicalDeviceCount", obj["physicalDeviceCount"], (o.physicalDeviceCount)); + + (o.pPhysicalDevices) = (VkPhysicalDevice*)s_globalMem.allocate((o.physicalDeviceCount), sizeof(VkPhysicalDevice)); + Json::Value& obj_pPhysicalDevices_arr = obj["pPhysicalDevices"]; + for (unsigned int i = 0; i < obj_pPhysicalDevices_arr.size(); i++) { + parse_VkPhysicalDevice("pPhysicalDevices", obj_pPhysicalDevices_arr[i], const_cast((o.pPhysicalDevices[i]))); + } + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkBufferMemoryRequirementsInfo2(const char* s, Json::Value& obj, VkBufferMemoryRequirementsInfo2& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkBufferMemoryRequirementsInfo2*)parsePNextChain(obj); + + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkImageMemoryRequirementsInfo2(const char* s, Json::Value& obj, VkImageMemoryRequirementsInfo2& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImageMemoryRequirementsInfo2*)parsePNextChain(obj); + + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkMemoryRequirements2(const char* s, Json::Value& obj, VkMemoryRequirements2& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkMemoryRequirements2*)parsePNextChain(obj); + + parse_VkMemoryRequirements("memoryRequirements", obj["memoryRequirements"], (o.memoryRequirements)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceFeatures2(const char* s, Json::Value& obj, VkPhysicalDeviceFeatures2& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceFeatures2*)parsePNextChain(obj); + + parse_VkPhysicalDeviceFeatures("features", obj["features"], (o.features)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceProperties2(const char* s, Json::Value& obj, VkPhysicalDeviceProperties2& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceProperties2*)parsePNextChain(obj); + + parse_VkPhysicalDeviceProperties("properties", obj["properties"], (o.properties)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkFormatProperties2(const char* s, Json::Value& obj, VkFormatProperties2& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkFormatProperties2*)parsePNextChain(obj); + + parse_VkFormatProperties("formatProperties", obj["formatProperties"], (o.formatProperties)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkImageFormatProperties2(const char* s, Json::Value& obj, VkImageFormatProperties2& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImageFormatProperties2*)parsePNextChain(obj); + + parse_VkImageFormatProperties("imageFormatProperties", obj["imageFormatProperties"], (o.imageFormatProperties)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceImageFormatInfo2(const char* s, Json::Value& obj, VkPhysicalDeviceImageFormatInfo2& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceImageFormatInfo2*)parsePNextChain(obj); + + parse_VkFormat("format", obj["format"], (o.format)); + + parse_VkImageType("type", obj["type"], (o.type)); + + parse_VkImageTiling("tiling", obj["tiling"], (o.tiling)); + + parse_VkImageUsageFlags("usage", obj["usage"], (o.usage)); + + parse_VkImageCreateFlags("flags", obj["flags"], (o.flags)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkQueueFamilyProperties2(const char* s, Json::Value& obj, VkQueueFamilyProperties2& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkQueueFamilyProperties2*)parsePNextChain(obj); + + parse_VkQueueFamilyProperties("queueFamilyProperties", obj["queueFamilyProperties"], (o.queueFamilyProperties)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceMemoryProperties2(const char* s, Json::Value& obj, VkPhysicalDeviceMemoryProperties2& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceMemoryProperties2*)parsePNextChain(obj); + + parse_VkPhysicalDeviceMemoryProperties("memoryProperties", obj["memoryProperties"], (o.memoryProperties)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDevicePointClippingProperties(const char* s, Json::Value& obj, VkPhysicalDevicePointClippingProperties& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDevicePointClippingProperties*)parsePNextChain(obj); + + parse_VkPointClippingBehavior("pointClippingBehavior", obj["pointClippingBehavior"], (o.pointClippingBehavior)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkInputAttachmentAspectReference(const char* s, Json::Value& obj, VkInputAttachmentAspectReference& o) { + + parse_uint32_t("subpass", obj["subpass"], (o.subpass)); + + parse_uint32_t("inputAttachmentIndex", obj["inputAttachmentIndex"], (o.inputAttachmentIndex)); + + parse_VkImageAspectFlags("aspectMask", obj["aspectMask"], (o.aspectMask)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkRenderPassInputAttachmentAspectCreateInfo(const char* s, Json::Value& obj, VkRenderPassInputAttachmentAspectCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkRenderPassInputAttachmentAspectCreateInfo*)parsePNextChain(obj); + + parse_uint32_t("aspectReferenceCount", obj["aspectReferenceCount"], (o.aspectReferenceCount)); + + (o.pAspectReferences) = (VkInputAttachmentAspectReference*)s_globalMem.allocate((o.aspectReferenceCount), sizeof(VkInputAttachmentAspectReference)); + Json::Value& obj_pAspectReferences = obj["pAspectReferences"]; + if (obj_pAspectReferences.size() == 0) (o.pAspectReferences) = nullptr; + else { + for (unsigned int i = 0; i < (o.aspectReferenceCount); i++) { + parse_VkInputAttachmentAspectReference("pAspectReferences", obj_pAspectReferences[i], const_cast((o.pAspectReferences[i]))); + } + } + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkImageViewUsageCreateInfo(const char* s, Json::Value& obj, VkImageViewUsageCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImageViewUsageCreateInfo*)parsePNextChain(obj); + + parse_VkImageUsageFlags("usage", obj["usage"], (o.usage)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPipelineTessellationDomainOriginStateCreateInfo(const char* s, Json::Value& obj, VkPipelineTessellationDomainOriginStateCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineTessellationDomainOriginStateCreateInfo*)parsePNextChain(obj); + + parse_VkTessellationDomainOrigin("domainOrigin", obj["domainOrigin"], (o.domainOrigin)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkRenderPassMultiviewCreateInfo(const char* s, Json::Value& obj, VkRenderPassMultiviewCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkRenderPassMultiviewCreateInfo*)parsePNextChain(obj); + + parse_uint32_t("subpassCount", obj["subpassCount"], (o.subpassCount)); + + (o.pViewMasks) = (uint32_t*)s_globalMem.allocate((o.subpassCount), sizeof(uint32_t)); + Json::Value& obj_pViewMasks_arr = obj["pViewMasks"]; + for (unsigned int i = 0; i < obj_pViewMasks_arr.size(); i++) { + parse_uint32_t("pViewMasks", obj_pViewMasks_arr[i], const_cast((o.pViewMasks[i]))); + } + + parse_uint32_t("dependencyCount", obj["dependencyCount"], (o.dependencyCount)); + + (o.pViewOffsets) = (int32_t*)s_globalMem.allocate((o.dependencyCount), sizeof(int32_t)); + Json::Value& obj_pViewOffsets_arr = obj["pViewOffsets"]; + for (unsigned int i = 0; i < obj_pViewOffsets_arr.size(); i++) { + parse_int32_t("pViewOffsets", obj_pViewOffsets_arr[i], const_cast((o.pViewOffsets[i]))); + } + + parse_uint32_t("correlationMaskCount", obj["correlationMaskCount"], (o.correlationMaskCount)); + + (o.pCorrelationMasks) = (uint32_t*)s_globalMem.allocate((o.correlationMaskCount), sizeof(uint32_t)); + Json::Value& obj_pCorrelationMasks_arr = obj["pCorrelationMasks"]; + for (unsigned int i = 0; i < obj_pCorrelationMasks_arr.size(); i++) { + parse_uint32_t("pCorrelationMasks", obj_pCorrelationMasks_arr[i], const_cast((o.pCorrelationMasks[i]))); + } + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceMultiviewFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceMultiviewFeatures& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceMultiviewFeatures*)parsePNextChain(obj); + + parse_VkBool32("multiview", obj["multiview"], (o.multiview)); + + parse_VkBool32("multiviewGeometryShader", obj["multiviewGeometryShader"], (o.multiviewGeometryShader)); + + parse_VkBool32("multiviewTessellationShader", obj["multiviewTessellationShader"], (o.multiviewTessellationShader)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceMultiviewProperties(const char* s, Json::Value& obj, VkPhysicalDeviceMultiviewProperties& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceMultiviewProperties*)parsePNextChain(obj); + + parse_uint32_t("maxMultiviewViewCount", obj["maxMultiviewViewCount"], (o.maxMultiviewViewCount)); + + parse_uint32_t("maxMultiviewInstanceIndex", obj["maxMultiviewInstanceIndex"], (o.maxMultiviewInstanceIndex)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceVariablePointersFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceVariablePointersFeatures& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceVariablePointersFeatures*)parsePNextChain(obj); + + parse_VkBool32("variablePointersStorageBuffer", obj["variablePointersStorageBuffer"], (o.variablePointersStorageBuffer)); + + parse_VkBool32("variablePointers", obj["variablePointers"], (o.variablePointers)); + +} +#endif + +#ifdef VK_VERSION_1_1 +typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures; +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceProtectedMemoryFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceProtectedMemoryFeatures& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceProtectedMemoryFeatures*)parsePNextChain(obj); + + parse_VkBool32("protectedMemory", obj["protectedMemory"], (o.protectedMemory)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceProtectedMemoryProperties(const char* s, Json::Value& obj, VkPhysicalDeviceProtectedMemoryProperties& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceProtectedMemoryProperties*)parsePNextChain(obj); + + parse_VkBool32("protectedNoFault", obj["protectedNoFault"], (o.protectedNoFault)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkDeviceQueueInfo2(const char* s, Json::Value& obj, VkDeviceQueueInfo2& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDeviceQueueInfo2*)parsePNextChain(obj); + + parse_VkDeviceQueueCreateFlags("flags", obj["flags"], (o.flags)); + + parse_uint32_t("queueFamilyIndex", obj["queueFamilyIndex"], (o.queueFamilyIndex)); + + parse_uint32_t("queueIndex", obj["queueIndex"], (o.queueIndex)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkProtectedSubmitInfo(const char* s, Json::Value& obj, VkProtectedSubmitInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkProtectedSubmitInfo*)parsePNextChain(obj); + + parse_VkBool32("protectedSubmit", obj["protectedSubmit"], (o.protectedSubmit)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkSamplerYcbcrConversionCreateInfo(const char* s, Json::Value& obj, VkSamplerYcbcrConversionCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSamplerYcbcrConversionCreateInfo*)parsePNextChain(obj); + + parse_VkFormat("format", obj["format"], (o.format)); + + parse_VkSamplerYcbcrModelConversion("ycbcrModel", obj["ycbcrModel"], (o.ycbcrModel)); + + parse_VkSamplerYcbcrRange("ycbcrRange", obj["ycbcrRange"], (o.ycbcrRange)); + + parse_VkComponentMapping("components", obj["components"], (o.components)); + + parse_VkChromaLocation("xChromaOffset", obj["xChromaOffset"], (o.xChromaOffset)); + + parse_VkChromaLocation("yChromaOffset", obj["yChromaOffset"], (o.yChromaOffset)); + + parse_VkFilter("chromaFilter", obj["chromaFilter"], (o.chromaFilter)); + + parse_VkBool32("forceExplicitReconstruction", obj["forceExplicitReconstruction"], (o.forceExplicitReconstruction)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkSamplerYcbcrConversionInfo(const char* s, Json::Value& obj, VkSamplerYcbcrConversionInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSamplerYcbcrConversionInfo*)parsePNextChain(obj); + + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkBindImagePlaneMemoryInfo(const char* s, Json::Value& obj, VkBindImagePlaneMemoryInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkBindImagePlaneMemoryInfo*)parsePNextChain(obj); + + parse_VkImageAspectFlagBits("planeAspect", obj["planeAspect"], (o.planeAspect)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkImagePlaneMemoryRequirementsInfo(const char* s, Json::Value& obj, VkImagePlaneMemoryRequirementsInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImagePlaneMemoryRequirementsInfo*)parsePNextChain(obj); + + parse_VkImageAspectFlagBits("planeAspect", obj["planeAspect"], (o.planeAspect)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceSamplerYcbcrConversionFeatures& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceSamplerYcbcrConversionFeatures*)parsePNextChain(obj); + + parse_VkBool32("samplerYcbcrConversion", obj["samplerYcbcrConversion"], (o.samplerYcbcrConversion)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkSamplerYcbcrConversionImageFormatProperties(const char* s, Json::Value& obj, VkSamplerYcbcrConversionImageFormatProperties& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSamplerYcbcrConversionImageFormatProperties*)parsePNextChain(obj); + + parse_uint32_t("combinedImageSamplerDescriptorCount", obj["combinedImageSamplerDescriptorCount"], (o.combinedImageSamplerDescriptorCount)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkExternalMemoryProperties(const char* s, Json::Value& obj, VkExternalMemoryProperties& o) { + + parse_VkExternalMemoryFeatureFlags("externalMemoryFeatures", obj["externalMemoryFeatures"], (o.externalMemoryFeatures)); + + parse_VkExternalMemoryHandleTypeFlags("exportFromImportedHandleTypes", obj["exportFromImportedHandleTypes"], (o.exportFromImportedHandleTypes)); + + parse_VkExternalMemoryHandleTypeFlags("compatibleHandleTypes", obj["compatibleHandleTypes"], (o.compatibleHandleTypes)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceExternalImageFormatInfo(const char* s, Json::Value& obj, VkPhysicalDeviceExternalImageFormatInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceExternalImageFormatInfo*)parsePNextChain(obj); + + parse_VkExternalMemoryHandleTypeFlagBits("handleType", obj["handleType"], (o.handleType)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkExternalImageFormatProperties(const char* s, Json::Value& obj, VkExternalImageFormatProperties& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkExternalImageFormatProperties*)parsePNextChain(obj); + + parse_VkExternalMemoryProperties("externalMemoryProperties", obj["externalMemoryProperties"], (o.externalMemoryProperties)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceExternalBufferInfo(const char* s, Json::Value& obj, VkPhysicalDeviceExternalBufferInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceExternalBufferInfo*)parsePNextChain(obj); + + parse_VkBufferCreateFlags("flags", obj["flags"], (o.flags)); + + parse_VkBufferUsageFlags("usage", obj["usage"], (o.usage)); + + parse_VkExternalMemoryHandleTypeFlagBits("handleType", obj["handleType"], (o.handleType)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkExternalBufferProperties(const char* s, Json::Value& obj, VkExternalBufferProperties& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkExternalBufferProperties*)parsePNextChain(obj); + + parse_VkExternalMemoryProperties("externalMemoryProperties", obj["externalMemoryProperties"], (o.externalMemoryProperties)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceIDProperties(const char* s, Json::Value& obj, VkPhysicalDeviceIDProperties& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceIDProperties*)parsePNextChain(obj); + + Json::Value& obj_deviceUUID_arr = obj["deviceUUID"]; + for (unsigned int i = 0; i < obj_deviceUUID_arr.size(); i++) { + parse_uint8_t("deviceUUID", obj_deviceUUID_arr[i], const_cast((o.deviceUUID[i]))); + } + + Json::Value& obj_driverUUID_arr = obj["driverUUID"]; + for (unsigned int i = 0; i < obj_driverUUID_arr.size(); i++) { + parse_uint8_t("driverUUID", obj_driverUUID_arr[i], const_cast((o.driverUUID[i]))); + } + + Json::Value& obj_deviceLUID_arr = obj["deviceLUID"]; + for (unsigned int i = 0; i < obj_deviceLUID_arr.size(); i++) { + parse_uint8_t("deviceLUID", obj_deviceLUID_arr[i], const_cast((o.deviceLUID[i]))); + } + + parse_uint32_t("deviceNodeMask", obj["deviceNodeMask"], (o.deviceNodeMask)); + + parse_VkBool32("deviceLUIDValid", obj["deviceLUIDValid"], (o.deviceLUIDValid)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkExternalMemoryImageCreateInfo(const char* s, Json::Value& obj, VkExternalMemoryImageCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkExternalMemoryImageCreateInfo*)parsePNextChain(obj); + + parse_VkExternalMemoryHandleTypeFlags("handleTypes", obj["handleTypes"], (o.handleTypes)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkExternalMemoryBufferCreateInfo(const char* s, Json::Value& obj, VkExternalMemoryBufferCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkExternalMemoryBufferCreateInfo*)parsePNextChain(obj); + + parse_VkExternalMemoryHandleTypeFlags("handleTypes", obj["handleTypes"], (o.handleTypes)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkExportMemoryAllocateInfo(const char* s, Json::Value& obj, VkExportMemoryAllocateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkExportMemoryAllocateInfo*)parsePNextChain(obj); + + parse_VkExternalMemoryHandleTypeFlags("handleTypes", obj["handleTypes"], (o.handleTypes)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceExternalFenceInfo(const char* s, Json::Value& obj, VkPhysicalDeviceExternalFenceInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceExternalFenceInfo*)parsePNextChain(obj); + + parse_VkExternalFenceHandleTypeFlagBits("handleType", obj["handleType"], (o.handleType)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkExternalFenceProperties(const char* s, Json::Value& obj, VkExternalFenceProperties& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkExternalFenceProperties*)parsePNextChain(obj); + + parse_VkExternalFenceHandleTypeFlags("exportFromImportedHandleTypes", obj["exportFromImportedHandleTypes"], (o.exportFromImportedHandleTypes)); + + parse_VkExternalFenceHandleTypeFlags("compatibleHandleTypes", obj["compatibleHandleTypes"], (o.compatibleHandleTypes)); + + parse_VkExternalFenceFeatureFlags("externalFenceFeatures", obj["externalFenceFeatures"], (o.externalFenceFeatures)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkExportFenceCreateInfo(const char* s, Json::Value& obj, VkExportFenceCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkExportFenceCreateInfo*)parsePNextChain(obj); + + parse_VkExternalFenceHandleTypeFlags("handleTypes", obj["handleTypes"], (o.handleTypes)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkExportSemaphoreCreateInfo(const char* s, Json::Value& obj, VkExportSemaphoreCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkExportSemaphoreCreateInfo*)parsePNextChain(obj); + + parse_VkExternalSemaphoreHandleTypeFlags("handleTypes", obj["handleTypes"], (o.handleTypes)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceExternalSemaphoreInfo(const char* s, Json::Value& obj, VkPhysicalDeviceExternalSemaphoreInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceExternalSemaphoreInfo*)parsePNextChain(obj); + + parse_VkExternalSemaphoreHandleTypeFlagBits("handleType", obj["handleType"], (o.handleType)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkExternalSemaphoreProperties(const char* s, Json::Value& obj, VkExternalSemaphoreProperties& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkExternalSemaphoreProperties*)parsePNextChain(obj); + + parse_VkExternalSemaphoreHandleTypeFlags("exportFromImportedHandleTypes", obj["exportFromImportedHandleTypes"], (o.exportFromImportedHandleTypes)); + + parse_VkExternalSemaphoreHandleTypeFlags("compatibleHandleTypes", obj["compatibleHandleTypes"], (o.compatibleHandleTypes)); + + parse_VkExternalSemaphoreFeatureFlags("externalSemaphoreFeatures", obj["externalSemaphoreFeatures"], (o.externalSemaphoreFeatures)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceMaintenance3Properties(const char* s, Json::Value& obj, VkPhysicalDeviceMaintenance3Properties& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceMaintenance3Properties*)parsePNextChain(obj); + + parse_uint32_t("maxPerSetDescriptors", obj["maxPerSetDescriptors"], (o.maxPerSetDescriptors)); + + parse_VkDeviceSize("maxMemoryAllocationSize", obj["maxMemoryAllocationSize"], (o.maxMemoryAllocationSize)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkDescriptorSetLayoutSupport(const char* s, Json::Value& obj, VkDescriptorSetLayoutSupport& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDescriptorSetLayoutSupport*)parsePNextChain(obj); + + parse_VkBool32("supported", obj["supported"], (o.supported)); + +} +#endif + +#ifdef VK_VERSION_1_1 +static void parse_VkPhysicalDeviceShaderDrawParametersFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceShaderDrawParametersFeatures& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceShaderDrawParametersFeatures*)parsePNextChain(obj); + + parse_VkBool32("shaderDrawParameters", obj["shaderDrawParameters"], (o.shaderDrawParameters)); + +} +#endif + +#ifdef VK_VERSION_1_1 +typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures; +#endif + +#ifdef VK_VERSION_1_2 +static std::map VkDriverId_map = { + std::make_pair("VK_DRIVER_ID_AMD_PROPRIETARY", 1), + std::make_pair("VK_DRIVER_ID_AMD_OPEN_SOURCE", 2), + std::make_pair("VK_DRIVER_ID_MESA_RADV", 3), + std::make_pair("VK_DRIVER_ID_NVIDIA_PROPRIETARY", 4), + std::make_pair("VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS", 5), + std::make_pair("VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA", 6), + std::make_pair("VK_DRIVER_ID_IMAGINATION_PROPRIETARY", 7), + std::make_pair("VK_DRIVER_ID_QUALCOMM_PROPRIETARY", 8), + std::make_pair("VK_DRIVER_ID_ARM_PROPRIETARY", 9), + std::make_pair("VK_DRIVER_ID_GOOGLE_SWIFTSHADER", 10), + std::make_pair("VK_DRIVER_ID_GGP_PROPRIETARY", 11), + std::make_pair("VK_DRIVER_ID_BROADCOM_PROPRIETARY", 12), + std::make_pair("VK_DRIVER_ID_MESA_LLVMPIPE", 13), + std::make_pair("VK_DRIVER_ID_MOLTENVK", 14), + std::make_pair("VK_DRIVER_ID_COREAVI_PROPRIETARY", 15), + std::make_pair("VK_DRIVER_ID_JUICE_PROPRIETARY", 16), + std::make_pair("VK_DRIVER_ID_VERISILICON_PROPRIETARY", 17), + std::make_pair("VK_DRIVER_ID_MESA_TURNIP", 18), + std::make_pair("VK_DRIVER_ID_MESA_V3DV", 19), + std::make_pair("VK_DRIVER_ID_MESA_PANVK", 20), + std::make_pair("VK_DRIVER_ID_SAMSUNG_PROPRIETARY", 21), +}; +static void parse_VkDriverId(const char* s, Json::Value& obj, VkDriverId& o) { + std::string _res = obj.asString(); + o = (VkDriverId)VkDriverId_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_2 +static std::map VkShaderFloatControlsIndependence_map = { + std::make_pair("VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY", 0), + std::make_pair("VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL", 1), + std::make_pair("VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE", 2), +}; +static void parse_VkShaderFloatControlsIndependence(const char* s, Json::Value& obj, VkShaderFloatControlsIndependence& o) { + std::string _res = obj.asString(); + o = (VkShaderFloatControlsIndependence)VkShaderFloatControlsIndependence_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_2 +static std::map VkResolveModeFlagBits_map = { + std::make_pair("VK_RESOLVE_MODE_NONE", 0), + std::make_pair("VK_RESOLVE_MODE_SAMPLE_ZERO_BIT", 1UL << 0), + std::make_pair("VK_RESOLVE_MODE_AVERAGE_BIT", 1UL << 1), + std::make_pair("VK_RESOLVE_MODE_MIN_BIT", 1UL << 2), + std::make_pair("VK_RESOLVE_MODE_MAX_BIT", 1UL << 3), +}; +static void parse_VkResolveModeFlagBits(const char* s, Json::Value& obj, VkResolveModeFlagBits& o) { + std::string _res = obj.asString(); + o = (VkResolveModeFlagBits)VkResolveModeFlagBits_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_2 +static std::map VkDescriptorBindingFlagBits_map = { + std::make_pair("VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT", 1UL << 0), + std::make_pair("VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT", 1UL << 1), + std::make_pair("VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT", 1UL << 2), + std::make_pair("VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT", 1UL << 3), + std::make_pair("VK_DESCRIPTOR_BINDING_RESERVED_4_BIT_QCOM", 1UL << 4), +}; +static void parse_VkDescriptorBindingFlagBits(const char* s, Json::Value& obj, VkDescriptorBindingFlagBits& o) { + std::string _res = obj.asString(); + o = (VkDescriptorBindingFlagBits)VkDescriptorBindingFlagBits_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_2 +static std::map VkSamplerReductionMode_map = { + std::make_pair("VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE", 0), + std::make_pair("VK_SAMPLER_REDUCTION_MODE_MIN", 1), + std::make_pair("VK_SAMPLER_REDUCTION_MODE_MAX", 2), +}; +static void parse_VkSamplerReductionMode(const char* s, Json::Value& obj, VkSamplerReductionMode& o) { + std::string _res = obj.asString(); + o = (VkSamplerReductionMode)VkSamplerReductionMode_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_2 +static std::map VkSemaphoreType_map = { + std::make_pair("VK_SEMAPHORE_TYPE_BINARY", 0), + std::make_pair("VK_SEMAPHORE_TYPE_TIMELINE", 1), +}; +static void parse_VkSemaphoreType(const char* s, Json::Value& obj, VkSemaphoreType& o) { + std::string _res = obj.asString(); + o = (VkSemaphoreType)VkSemaphoreType_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_2 +static std::map VkSemaphoreWaitFlagBits_map = { + std::make_pair("VK_SEMAPHORE_WAIT_ANY_BIT", 1UL << 0), +}; +static void parse_VkSemaphoreWaitFlagBits(const char* s, Json::Value& obj, VkSemaphoreWaitFlagBits& o) { + std::string _res = obj.asString(); + o = (VkSemaphoreWaitFlagBits)VkSemaphoreWaitFlagBits_map[std::string(_res)]; +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkResolveModeFlags(const char* s, Json::Value& obj, VkResolveModeFlags& o) { + o = (VkResolveModeFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkResolveModeFlagBits)VkResolveModeFlagBits_map[it]; + } +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkDescriptorBindingFlags(const char* s, Json::Value& obj, VkDescriptorBindingFlags& o) { + o = (VkDescriptorBindingFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkDescriptorBindingFlagBits)VkDescriptorBindingFlagBits_map[it]; + } +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkSemaphoreWaitFlags(const char* s, Json::Value& obj, VkSemaphoreWaitFlags& o) { + o = (VkSemaphoreWaitFlags)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkSemaphoreWaitFlagBits)VkSemaphoreWaitFlagBits_map[it]; + } +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceVulkan11Features(const char* s, Json::Value& obj, VkPhysicalDeviceVulkan11Features& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceVulkan11Features*)parsePNextChain(obj); + + parse_VkBool32("storageBuffer16BitAccess", obj["storageBuffer16BitAccess"], (o.storageBuffer16BitAccess)); + + parse_VkBool32("uniformAndStorageBuffer16BitAccess", obj["uniformAndStorageBuffer16BitAccess"], (o.uniformAndStorageBuffer16BitAccess)); + + parse_VkBool32("storagePushConstant16", obj["storagePushConstant16"], (o.storagePushConstant16)); + + parse_VkBool32("storageInputOutput16", obj["storageInputOutput16"], (o.storageInputOutput16)); + + parse_VkBool32("multiview", obj["multiview"], (o.multiview)); + + parse_VkBool32("multiviewGeometryShader", obj["multiviewGeometryShader"], (o.multiviewGeometryShader)); + + parse_VkBool32("multiviewTessellationShader", obj["multiviewTessellationShader"], (o.multiviewTessellationShader)); + + parse_VkBool32("variablePointersStorageBuffer", obj["variablePointersStorageBuffer"], (o.variablePointersStorageBuffer)); + + parse_VkBool32("variablePointers", obj["variablePointers"], (o.variablePointers)); + + parse_VkBool32("protectedMemory", obj["protectedMemory"], (o.protectedMemory)); + + parse_VkBool32("samplerYcbcrConversion", obj["samplerYcbcrConversion"], (o.samplerYcbcrConversion)); + + parse_VkBool32("shaderDrawParameters", obj["shaderDrawParameters"], (o.shaderDrawParameters)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceVulkan11Properties(const char* s, Json::Value& obj, VkPhysicalDeviceVulkan11Properties& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceVulkan11Properties*)parsePNextChain(obj); + + Json::Value& obj_deviceUUID_arr = obj["deviceUUID"]; + for (unsigned int i = 0; i < obj_deviceUUID_arr.size(); i++) { + parse_uint8_t("deviceUUID", obj_deviceUUID_arr[i], const_cast((o.deviceUUID[i]))); + } + + Json::Value& obj_driverUUID_arr = obj["driverUUID"]; + for (unsigned int i = 0; i < obj_driverUUID_arr.size(); i++) { + parse_uint8_t("driverUUID", obj_driverUUID_arr[i], const_cast((o.driverUUID[i]))); + } + + Json::Value& obj_deviceLUID_arr = obj["deviceLUID"]; + for (unsigned int i = 0; i < obj_deviceLUID_arr.size(); i++) { + parse_uint8_t("deviceLUID", obj_deviceLUID_arr[i], const_cast((o.deviceLUID[i]))); + } + + parse_uint32_t("deviceNodeMask", obj["deviceNodeMask"], (o.deviceNodeMask)); + + parse_VkBool32("deviceLUIDValid", obj["deviceLUIDValid"], (o.deviceLUIDValid)); + + parse_uint32_t("subgroupSize", obj["subgroupSize"], (o.subgroupSize)); + + parse_VkShaderStageFlags("subgroupSupportedStages", obj["subgroupSupportedStages"], (o.subgroupSupportedStages)); + + parse_VkSubgroupFeatureFlags("subgroupSupportedOperations", obj["subgroupSupportedOperations"], (o.subgroupSupportedOperations)); + + parse_VkBool32("subgroupQuadOperationsInAllStages", obj["subgroupQuadOperationsInAllStages"], (o.subgroupQuadOperationsInAllStages)); + + parse_VkPointClippingBehavior("pointClippingBehavior", obj["pointClippingBehavior"], (o.pointClippingBehavior)); + + parse_uint32_t("maxMultiviewViewCount", obj["maxMultiviewViewCount"], (o.maxMultiviewViewCount)); + + parse_uint32_t("maxMultiviewInstanceIndex", obj["maxMultiviewInstanceIndex"], (o.maxMultiviewInstanceIndex)); + + parse_VkBool32("protectedNoFault", obj["protectedNoFault"], (o.protectedNoFault)); + + parse_uint32_t("maxPerSetDescriptors", obj["maxPerSetDescriptors"], (o.maxPerSetDescriptors)); + + parse_VkDeviceSize("maxMemoryAllocationSize", obj["maxMemoryAllocationSize"], (o.maxMemoryAllocationSize)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceVulkan12Features(const char* s, Json::Value& obj, VkPhysicalDeviceVulkan12Features& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceVulkan12Features*)parsePNextChain(obj); + + parse_VkBool32("samplerMirrorClampToEdge", obj["samplerMirrorClampToEdge"], (o.samplerMirrorClampToEdge)); + + parse_VkBool32("drawIndirectCount", obj["drawIndirectCount"], (o.drawIndirectCount)); + + parse_VkBool32("storageBuffer8BitAccess", obj["storageBuffer8BitAccess"], (o.storageBuffer8BitAccess)); + + parse_VkBool32("uniformAndStorageBuffer8BitAccess", obj["uniformAndStorageBuffer8BitAccess"], (o.uniformAndStorageBuffer8BitAccess)); + + parse_VkBool32("storagePushConstant8", obj["storagePushConstant8"], (o.storagePushConstant8)); + + parse_VkBool32("shaderBufferInt64Atomics", obj["shaderBufferInt64Atomics"], (o.shaderBufferInt64Atomics)); + + parse_VkBool32("shaderSharedInt64Atomics", obj["shaderSharedInt64Atomics"], (o.shaderSharedInt64Atomics)); + + parse_VkBool32("shaderFloat16", obj["shaderFloat16"], (o.shaderFloat16)); + + parse_VkBool32("shaderInt8", obj["shaderInt8"], (o.shaderInt8)); + + parse_VkBool32("descriptorIndexing", obj["descriptorIndexing"], (o.descriptorIndexing)); + + parse_VkBool32("shaderInputAttachmentArrayDynamicIndexing", obj["shaderInputAttachmentArrayDynamicIndexing"], (o.shaderInputAttachmentArrayDynamicIndexing)); + + parse_VkBool32("shaderUniformTexelBufferArrayDynamicIndexing", obj["shaderUniformTexelBufferArrayDynamicIndexing"], (o.shaderUniformTexelBufferArrayDynamicIndexing)); + + parse_VkBool32("shaderStorageTexelBufferArrayDynamicIndexing", obj["shaderStorageTexelBufferArrayDynamicIndexing"], (o.shaderStorageTexelBufferArrayDynamicIndexing)); + + parse_VkBool32("shaderUniformBufferArrayNonUniformIndexing", obj["shaderUniformBufferArrayNonUniformIndexing"], (o.shaderUniformBufferArrayNonUniformIndexing)); + + parse_VkBool32("shaderSampledImageArrayNonUniformIndexing", obj["shaderSampledImageArrayNonUniformIndexing"], (o.shaderSampledImageArrayNonUniformIndexing)); + + parse_VkBool32("shaderStorageBufferArrayNonUniformIndexing", obj["shaderStorageBufferArrayNonUniformIndexing"], (o.shaderStorageBufferArrayNonUniformIndexing)); + + parse_VkBool32("shaderStorageImageArrayNonUniformIndexing", obj["shaderStorageImageArrayNonUniformIndexing"], (o.shaderStorageImageArrayNonUniformIndexing)); + + parse_VkBool32("shaderInputAttachmentArrayNonUniformIndexing", obj["shaderInputAttachmentArrayNonUniformIndexing"], (o.shaderInputAttachmentArrayNonUniformIndexing)); + + parse_VkBool32("shaderUniformTexelBufferArrayNonUniformIndexing", obj["shaderUniformTexelBufferArrayNonUniformIndexing"], (o.shaderUniformTexelBufferArrayNonUniformIndexing)); + + parse_VkBool32("shaderStorageTexelBufferArrayNonUniformIndexing", obj["shaderStorageTexelBufferArrayNonUniformIndexing"], (o.shaderStorageTexelBufferArrayNonUniformIndexing)); + + parse_VkBool32("descriptorBindingUniformBufferUpdateAfterBind", obj["descriptorBindingUniformBufferUpdateAfterBind"], (o.descriptorBindingUniformBufferUpdateAfterBind)); + + parse_VkBool32("descriptorBindingSampledImageUpdateAfterBind", obj["descriptorBindingSampledImageUpdateAfterBind"], (o.descriptorBindingSampledImageUpdateAfterBind)); + + parse_VkBool32("descriptorBindingStorageImageUpdateAfterBind", obj["descriptorBindingStorageImageUpdateAfterBind"], (o.descriptorBindingStorageImageUpdateAfterBind)); + + parse_VkBool32("descriptorBindingStorageBufferUpdateAfterBind", obj["descriptorBindingStorageBufferUpdateAfterBind"], (o.descriptorBindingStorageBufferUpdateAfterBind)); + + parse_VkBool32("descriptorBindingUniformTexelBufferUpdateAfterBind", obj["descriptorBindingUniformTexelBufferUpdateAfterBind"], (o.descriptorBindingUniformTexelBufferUpdateAfterBind)); + + parse_VkBool32("descriptorBindingStorageTexelBufferUpdateAfterBind", obj["descriptorBindingStorageTexelBufferUpdateAfterBind"], (o.descriptorBindingStorageTexelBufferUpdateAfterBind)); + + parse_VkBool32("descriptorBindingUpdateUnusedWhilePending", obj["descriptorBindingUpdateUnusedWhilePending"], (o.descriptorBindingUpdateUnusedWhilePending)); + + parse_VkBool32("descriptorBindingPartiallyBound", obj["descriptorBindingPartiallyBound"], (o.descriptorBindingPartiallyBound)); + + parse_VkBool32("descriptorBindingVariableDescriptorCount", obj["descriptorBindingVariableDescriptorCount"], (o.descriptorBindingVariableDescriptorCount)); + + parse_VkBool32("runtimeDescriptorArray", obj["runtimeDescriptorArray"], (o.runtimeDescriptorArray)); + + parse_VkBool32("samplerFilterMinmax", obj["samplerFilterMinmax"], (o.samplerFilterMinmax)); + + parse_VkBool32("scalarBlockLayout", obj["scalarBlockLayout"], (o.scalarBlockLayout)); + + parse_VkBool32("imagelessFramebuffer", obj["imagelessFramebuffer"], (o.imagelessFramebuffer)); + + parse_VkBool32("uniformBufferStandardLayout", obj["uniformBufferStandardLayout"], (o.uniformBufferStandardLayout)); + + parse_VkBool32("shaderSubgroupExtendedTypes", obj["shaderSubgroupExtendedTypes"], (o.shaderSubgroupExtendedTypes)); + + parse_VkBool32("separateDepthStencilLayouts", obj["separateDepthStencilLayouts"], (o.separateDepthStencilLayouts)); + + parse_VkBool32("hostQueryReset", obj["hostQueryReset"], (o.hostQueryReset)); + + parse_VkBool32("timelineSemaphore", obj["timelineSemaphore"], (o.timelineSemaphore)); + + parse_VkBool32("bufferDeviceAddress", obj["bufferDeviceAddress"], (o.bufferDeviceAddress)); + + parse_VkBool32("bufferDeviceAddressCaptureReplay", obj["bufferDeviceAddressCaptureReplay"], (o.bufferDeviceAddressCaptureReplay)); + + parse_VkBool32("bufferDeviceAddressMultiDevice", obj["bufferDeviceAddressMultiDevice"], (o.bufferDeviceAddressMultiDevice)); + + parse_VkBool32("vulkanMemoryModel", obj["vulkanMemoryModel"], (o.vulkanMemoryModel)); + + parse_VkBool32("vulkanMemoryModelDeviceScope", obj["vulkanMemoryModelDeviceScope"], (o.vulkanMemoryModelDeviceScope)); + + parse_VkBool32("vulkanMemoryModelAvailabilityVisibilityChains", obj["vulkanMemoryModelAvailabilityVisibilityChains"], (o.vulkanMemoryModelAvailabilityVisibilityChains)); + + parse_VkBool32("shaderOutputViewportIndex", obj["shaderOutputViewportIndex"], (o.shaderOutputViewportIndex)); + + parse_VkBool32("shaderOutputLayer", obj["shaderOutputLayer"], (o.shaderOutputLayer)); + + parse_VkBool32("subgroupBroadcastDynamicId", obj["subgroupBroadcastDynamicId"], (o.subgroupBroadcastDynamicId)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkConformanceVersion(const char* s, Json::Value& obj, VkConformanceVersion& o) { + + parse_uint8_t("major", obj["major"], (o.major)); + + parse_uint8_t("minor", obj["minor"], (o.minor)); + + parse_uint8_t("subminor", obj["subminor"], (o.subminor)); + + parse_uint8_t("patch", obj["patch"], (o.patch)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceVulkan12Properties(const char* s, Json::Value& obj, VkPhysicalDeviceVulkan12Properties& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceVulkan12Properties*)parsePNextChain(obj); + + parse_VkDriverId("driverID", obj["driverID"], (o.driverID)); + + /** TODO: Handle this - driverName **/ + + /** TODO: Handle this - driverInfo **/ + + parse_VkConformanceVersion("conformanceVersion", obj["conformanceVersion"], (o.conformanceVersion)); + + parse_VkShaderFloatControlsIndependence("denormBehaviorIndependence", obj["denormBehaviorIndependence"], (o.denormBehaviorIndependence)); + + parse_VkShaderFloatControlsIndependence("roundingModeIndependence", obj["roundingModeIndependence"], (o.roundingModeIndependence)); + + parse_VkBool32("shaderSignedZeroInfNanPreserveFloat16", obj["shaderSignedZeroInfNanPreserveFloat16"], (o.shaderSignedZeroInfNanPreserveFloat16)); + + parse_VkBool32("shaderSignedZeroInfNanPreserveFloat32", obj["shaderSignedZeroInfNanPreserveFloat32"], (o.shaderSignedZeroInfNanPreserveFloat32)); + + parse_VkBool32("shaderSignedZeroInfNanPreserveFloat64", obj["shaderSignedZeroInfNanPreserveFloat64"], (o.shaderSignedZeroInfNanPreserveFloat64)); + + parse_VkBool32("shaderDenormPreserveFloat16", obj["shaderDenormPreserveFloat16"], (o.shaderDenormPreserveFloat16)); + + parse_VkBool32("shaderDenormPreserveFloat32", obj["shaderDenormPreserveFloat32"], (o.shaderDenormPreserveFloat32)); + + parse_VkBool32("shaderDenormPreserveFloat64", obj["shaderDenormPreserveFloat64"], (o.shaderDenormPreserveFloat64)); + + parse_VkBool32("shaderDenormFlushToZeroFloat16", obj["shaderDenormFlushToZeroFloat16"], (o.shaderDenormFlushToZeroFloat16)); + + parse_VkBool32("shaderDenormFlushToZeroFloat32", obj["shaderDenormFlushToZeroFloat32"], (o.shaderDenormFlushToZeroFloat32)); + + parse_VkBool32("shaderDenormFlushToZeroFloat64", obj["shaderDenormFlushToZeroFloat64"], (o.shaderDenormFlushToZeroFloat64)); + + parse_VkBool32("shaderRoundingModeRTEFloat16", obj["shaderRoundingModeRTEFloat16"], (o.shaderRoundingModeRTEFloat16)); + + parse_VkBool32("shaderRoundingModeRTEFloat32", obj["shaderRoundingModeRTEFloat32"], (o.shaderRoundingModeRTEFloat32)); + + parse_VkBool32("shaderRoundingModeRTEFloat64", obj["shaderRoundingModeRTEFloat64"], (o.shaderRoundingModeRTEFloat64)); + + parse_VkBool32("shaderRoundingModeRTZFloat16", obj["shaderRoundingModeRTZFloat16"], (o.shaderRoundingModeRTZFloat16)); + + parse_VkBool32("shaderRoundingModeRTZFloat32", obj["shaderRoundingModeRTZFloat32"], (o.shaderRoundingModeRTZFloat32)); + + parse_VkBool32("shaderRoundingModeRTZFloat64", obj["shaderRoundingModeRTZFloat64"], (o.shaderRoundingModeRTZFloat64)); + + parse_uint32_t("maxUpdateAfterBindDescriptorsInAllPools", obj["maxUpdateAfterBindDescriptorsInAllPools"], (o.maxUpdateAfterBindDescriptorsInAllPools)); + + parse_VkBool32("shaderUniformBufferArrayNonUniformIndexingNative", obj["shaderUniformBufferArrayNonUniformIndexingNative"], (o.shaderUniformBufferArrayNonUniformIndexingNative)); + + parse_VkBool32("shaderSampledImageArrayNonUniformIndexingNative", obj["shaderSampledImageArrayNonUniformIndexingNative"], (o.shaderSampledImageArrayNonUniformIndexingNative)); + + parse_VkBool32("shaderStorageBufferArrayNonUniformIndexingNative", obj["shaderStorageBufferArrayNonUniformIndexingNative"], (o.shaderStorageBufferArrayNonUniformIndexingNative)); + + parse_VkBool32("shaderStorageImageArrayNonUniformIndexingNative", obj["shaderStorageImageArrayNonUniformIndexingNative"], (o.shaderStorageImageArrayNonUniformIndexingNative)); + + parse_VkBool32("shaderInputAttachmentArrayNonUniformIndexingNative", obj["shaderInputAttachmentArrayNonUniformIndexingNative"], (o.shaderInputAttachmentArrayNonUniformIndexingNative)); + + parse_VkBool32("robustBufferAccessUpdateAfterBind", obj["robustBufferAccessUpdateAfterBind"], (o.robustBufferAccessUpdateAfterBind)); + + parse_VkBool32("quadDivergentImplicitLod", obj["quadDivergentImplicitLod"], (o.quadDivergentImplicitLod)); + + parse_uint32_t("maxPerStageDescriptorUpdateAfterBindSamplers", obj["maxPerStageDescriptorUpdateAfterBindSamplers"], (o.maxPerStageDescriptorUpdateAfterBindSamplers)); + + parse_uint32_t("maxPerStageDescriptorUpdateAfterBindUniformBuffers", obj["maxPerStageDescriptorUpdateAfterBindUniformBuffers"], (o.maxPerStageDescriptorUpdateAfterBindUniformBuffers)); + + parse_uint32_t("maxPerStageDescriptorUpdateAfterBindStorageBuffers", obj["maxPerStageDescriptorUpdateAfterBindStorageBuffers"], (o.maxPerStageDescriptorUpdateAfterBindStorageBuffers)); + + parse_uint32_t("maxPerStageDescriptorUpdateAfterBindSampledImages", obj["maxPerStageDescriptorUpdateAfterBindSampledImages"], (o.maxPerStageDescriptorUpdateAfterBindSampledImages)); + + parse_uint32_t("maxPerStageDescriptorUpdateAfterBindStorageImages", obj["maxPerStageDescriptorUpdateAfterBindStorageImages"], (o.maxPerStageDescriptorUpdateAfterBindStorageImages)); + + parse_uint32_t("maxPerStageDescriptorUpdateAfterBindInputAttachments", obj["maxPerStageDescriptorUpdateAfterBindInputAttachments"], (o.maxPerStageDescriptorUpdateAfterBindInputAttachments)); + + parse_uint32_t("maxPerStageUpdateAfterBindResources", obj["maxPerStageUpdateAfterBindResources"], (o.maxPerStageUpdateAfterBindResources)); + + parse_uint32_t("maxDescriptorSetUpdateAfterBindSamplers", obj["maxDescriptorSetUpdateAfterBindSamplers"], (o.maxDescriptorSetUpdateAfterBindSamplers)); + + parse_uint32_t("maxDescriptorSetUpdateAfterBindUniformBuffers", obj["maxDescriptorSetUpdateAfterBindUniformBuffers"], (o.maxDescriptorSetUpdateAfterBindUniformBuffers)); + + parse_uint32_t("maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", obj["maxDescriptorSetUpdateAfterBindUniformBuffersDynamic"], (o.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic)); + + parse_uint32_t("maxDescriptorSetUpdateAfterBindStorageBuffers", obj["maxDescriptorSetUpdateAfterBindStorageBuffers"], (o.maxDescriptorSetUpdateAfterBindStorageBuffers)); + + parse_uint32_t("maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", obj["maxDescriptorSetUpdateAfterBindStorageBuffersDynamic"], (o.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic)); + + parse_uint32_t("maxDescriptorSetUpdateAfterBindSampledImages", obj["maxDescriptorSetUpdateAfterBindSampledImages"], (o.maxDescriptorSetUpdateAfterBindSampledImages)); + + parse_uint32_t("maxDescriptorSetUpdateAfterBindStorageImages", obj["maxDescriptorSetUpdateAfterBindStorageImages"], (o.maxDescriptorSetUpdateAfterBindStorageImages)); + + parse_uint32_t("maxDescriptorSetUpdateAfterBindInputAttachments", obj["maxDescriptorSetUpdateAfterBindInputAttachments"], (o.maxDescriptorSetUpdateAfterBindInputAttachments)); + + parse_VkResolveModeFlags("supportedDepthResolveModes", obj["supportedDepthResolveModes"], (o.supportedDepthResolveModes)); + + parse_VkResolveModeFlags("supportedStencilResolveModes", obj["supportedStencilResolveModes"], (o.supportedStencilResolveModes)); + + parse_VkBool32("independentResolveNone", obj["independentResolveNone"], (o.independentResolveNone)); + + parse_VkBool32("independentResolve", obj["independentResolve"], (o.independentResolve)); + + parse_VkBool32("filterMinmaxSingleComponentFormats", obj["filterMinmaxSingleComponentFormats"], (o.filterMinmaxSingleComponentFormats)); + + parse_VkBool32("filterMinmaxImageComponentMapping", obj["filterMinmaxImageComponentMapping"], (o.filterMinmaxImageComponentMapping)); + + parse_uint64_t("maxTimelineSemaphoreValueDifference", obj["maxTimelineSemaphoreValueDifference"], (o.maxTimelineSemaphoreValueDifference)); + + parse_VkSampleCountFlags("framebufferIntegerColorSampleCounts", obj["framebufferIntegerColorSampleCounts"], (o.framebufferIntegerColorSampleCounts)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkImageFormatListCreateInfo(const char* s, Json::Value& obj, VkImageFormatListCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImageFormatListCreateInfo*)parsePNextChain(obj); + + parse_uint32_t("viewFormatCount", obj["viewFormatCount"], (o.viewFormatCount)); + + (o.pViewFormats) = (VkFormat*)s_globalMem.allocate((o.viewFormatCount), sizeof(VkFormat)); + Json::Value& obj_pViewFormats_arr = obj["pViewFormats"]; + for (unsigned int i = 0; i < obj_pViewFormats_arr.size(); i++) { + parse_VkFormat("pViewFormats", obj_pViewFormats_arr[i], const_cast((o.pViewFormats[i]))); + } + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkAttachmentDescription2(const char* s, Json::Value& obj, VkAttachmentDescription2& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkAttachmentDescription2*)parsePNextChain(obj); + + parse_VkAttachmentDescriptionFlags("flags", obj["flags"], (o.flags)); + + parse_VkFormat("format", obj["format"], (o.format)); + + parse_VkSampleCountFlagBits("samples", obj["samples"], (o.samples)); + + parse_VkAttachmentLoadOp("loadOp", obj["loadOp"], (o.loadOp)); + + parse_VkAttachmentStoreOp("storeOp", obj["storeOp"], (o.storeOp)); + + parse_VkAttachmentLoadOp("stencilLoadOp", obj["stencilLoadOp"], (o.stencilLoadOp)); + + parse_VkAttachmentStoreOp("stencilStoreOp", obj["stencilStoreOp"], (o.stencilStoreOp)); + + parse_VkImageLayout("initialLayout", obj["initialLayout"], (o.initialLayout)); + + parse_VkImageLayout("finalLayout", obj["finalLayout"], (o.finalLayout)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkAttachmentReference2(const char* s, Json::Value& obj, VkAttachmentReference2& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkAttachmentReference2*)parsePNextChain(obj); + + parse_uint32_t("attachment", obj["attachment"], (o.attachment)); + + parse_VkImageLayout("layout", obj["layout"], (o.layout)); + + parse_VkImageAspectFlags("aspectMask", obj["aspectMask"], (o.aspectMask)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkSubpassDescription2(const char* s, Json::Value& obj, VkSubpassDescription2& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSubpassDescription2*)parsePNextChain(obj); + + parse_VkSubpassDescriptionFlags("flags", obj["flags"], (o.flags)); + + parse_VkPipelineBindPoint("pipelineBindPoint", obj["pipelineBindPoint"], (o.pipelineBindPoint)); + + parse_uint32_t("viewMask", obj["viewMask"], (o.viewMask)); + + parse_uint32_t("inputAttachmentCount", obj["inputAttachmentCount"], (o.inputAttachmentCount)); + + (o.pInputAttachments) = (VkAttachmentReference2*)s_globalMem.allocate((o.inputAttachmentCount), sizeof(VkAttachmentReference2)); + Json::Value& obj_pInputAttachments = obj["pInputAttachments"]; + if (obj_pInputAttachments.size() == 0) (o.pInputAttachments) = nullptr; + else { + for (unsigned int i = 0; i < (o.inputAttachmentCount); i++) { + parse_VkAttachmentReference2("pInputAttachments", obj_pInputAttachments[i], const_cast((o.pInputAttachments[i]))); + } + } + + parse_uint32_t("colorAttachmentCount", obj["colorAttachmentCount"], (o.colorAttachmentCount)); + + (o.pColorAttachments) = (VkAttachmentReference2*)s_globalMem.allocate((o.colorAttachmentCount), sizeof(VkAttachmentReference2)); + Json::Value& obj_pColorAttachments = obj["pColorAttachments"]; + if (obj_pColorAttachments.size() == 0) (o.pColorAttachments) = nullptr; + else { + for (unsigned int i = 0; i < (o.colorAttachmentCount); i++) { + parse_VkAttachmentReference2("pColorAttachments", obj_pColorAttachments[i], const_cast((o.pColorAttachments[i]))); + } + } + + (o.pResolveAttachments) = (VkAttachmentReference2*)s_globalMem.allocate((o.colorAttachmentCount), sizeof(VkAttachmentReference2)); + Json::Value& obj_pResolveAttachments = obj["pResolveAttachments"]; + if (obj_pResolveAttachments.size() == 0) (o.pResolveAttachments) = nullptr; + else { + for (unsigned int i = 0; i < (o.colorAttachmentCount); i++) { + parse_VkAttachmentReference2("pResolveAttachments", obj_pResolveAttachments[i], const_cast((o.pResolveAttachments[i]))); + } + } + + { + Json::Value& obj_pDepthStencilAttachment = obj["pDepthStencilAttachment"]; + const int sz = obj_pDepthStencilAttachment.size(); + if (obj_pDepthStencilAttachment.size() == 0) { + (o.pDepthStencilAttachment) = nullptr; + } else { + (o.pDepthStencilAttachment) = (VkAttachmentReference2*)s_globalMem.allocate(1, sizeof(VkAttachmentReference2)); + parse_VkAttachmentReference2("pDepthStencilAttachment", obj_pDepthStencilAttachment, const_cast(*(o.pDepthStencilAttachment))); + } + } + + parse_uint32_t("preserveAttachmentCount", obj["preserveAttachmentCount"], (o.preserveAttachmentCount)); + + (o.pPreserveAttachments) = (uint32_t*)s_globalMem.allocate((o.preserveAttachmentCount), sizeof(uint32_t)); + Json::Value& obj_pPreserveAttachments_arr = obj["pPreserveAttachments"]; + for (unsigned int i = 0; i < obj_pPreserveAttachments_arr.size(); i++) { + parse_uint32_t("pPreserveAttachments", obj_pPreserveAttachments_arr[i], const_cast((o.pPreserveAttachments[i]))); + } + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkSubpassDependency2(const char* s, Json::Value& obj, VkSubpassDependency2& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSubpassDependency2*)parsePNextChain(obj); + + parse_uint32_t("srcSubpass", obj["srcSubpass"], (o.srcSubpass)); + + parse_uint32_t("dstSubpass", obj["dstSubpass"], (o.dstSubpass)); + + parse_VkPipelineStageFlags("srcStageMask", obj["srcStageMask"], (o.srcStageMask)); + + parse_VkPipelineStageFlags("dstStageMask", obj["dstStageMask"], (o.dstStageMask)); + + parse_VkAccessFlags("srcAccessMask", obj["srcAccessMask"], (o.srcAccessMask)); + + parse_VkAccessFlags("dstAccessMask", obj["dstAccessMask"], (o.dstAccessMask)); + + parse_VkDependencyFlags("dependencyFlags", obj["dependencyFlags"], (o.dependencyFlags)); + + parse_int32_t("viewOffset", obj["viewOffset"], (o.viewOffset)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkRenderPassCreateInfo2(const char* s, Json::Value& obj, VkRenderPassCreateInfo2& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkRenderPassCreateInfo2*)parsePNextChain(obj); + + parse_VkRenderPassCreateFlags("flags", obj["flags"], (o.flags)); + + parse_uint32_t("attachmentCount", obj["attachmentCount"], (o.attachmentCount)); + + (o.pAttachments) = (VkAttachmentDescription2*)s_globalMem.allocate((o.attachmentCount), sizeof(VkAttachmentDescription2)); + Json::Value& obj_pAttachments = obj["pAttachments"]; + if (obj_pAttachments.size() == 0) (o.pAttachments) = nullptr; + else { + for (unsigned int i = 0; i < (o.attachmentCount); i++) { + parse_VkAttachmentDescription2("pAttachments", obj_pAttachments[i], const_cast((o.pAttachments[i]))); + } + } + + parse_uint32_t("subpassCount", obj["subpassCount"], (o.subpassCount)); + + (o.pSubpasses) = (VkSubpassDescription2*)s_globalMem.allocate((o.subpassCount), sizeof(VkSubpassDescription2)); + Json::Value& obj_pSubpasses = obj["pSubpasses"]; + if (obj_pSubpasses.size() == 0) (o.pSubpasses) = nullptr; + else { + for (unsigned int i = 0; i < (o.subpassCount); i++) { + parse_VkSubpassDescription2("pSubpasses", obj_pSubpasses[i], const_cast((o.pSubpasses[i]))); + } + } + + parse_uint32_t("dependencyCount", obj["dependencyCount"], (o.dependencyCount)); + + (o.pDependencies) = (VkSubpassDependency2*)s_globalMem.allocate((o.dependencyCount), sizeof(VkSubpassDependency2)); + Json::Value& obj_pDependencies = obj["pDependencies"]; + if (obj_pDependencies.size() == 0) (o.pDependencies) = nullptr; + else { + for (unsigned int i = 0; i < (o.dependencyCount); i++) { + parse_VkSubpassDependency2("pDependencies", obj_pDependencies[i], const_cast((o.pDependencies[i]))); + } + } + + parse_uint32_t("correlatedViewMaskCount", obj["correlatedViewMaskCount"], (o.correlatedViewMaskCount)); + + (o.pCorrelatedViewMasks) = (uint32_t*)s_globalMem.allocate((o.correlatedViewMaskCount), sizeof(uint32_t)); + Json::Value& obj_pCorrelatedViewMasks_arr = obj["pCorrelatedViewMasks"]; + for (unsigned int i = 0; i < obj_pCorrelatedViewMasks_arr.size(); i++) { + parse_uint32_t("pCorrelatedViewMasks", obj_pCorrelatedViewMasks_arr[i], const_cast((o.pCorrelatedViewMasks[i]))); + } + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkSubpassBeginInfo(const char* s, Json::Value& obj, VkSubpassBeginInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSubpassBeginInfo*)parsePNextChain(obj); + + parse_VkSubpassContents("contents", obj["contents"], (o.contents)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkSubpassEndInfo(const char* s, Json::Value& obj, VkSubpassEndInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSubpassEndInfo*)parsePNextChain(obj); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDevice8BitStorageFeatures(const char* s, Json::Value& obj, VkPhysicalDevice8BitStorageFeatures& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDevice8BitStorageFeatures*)parsePNextChain(obj); + + parse_VkBool32("storageBuffer8BitAccess", obj["storageBuffer8BitAccess"], (o.storageBuffer8BitAccess)); + + parse_VkBool32("uniformAndStorageBuffer8BitAccess", obj["uniformAndStorageBuffer8BitAccess"], (o.uniformAndStorageBuffer8BitAccess)); + + parse_VkBool32("storagePushConstant8", obj["storagePushConstant8"], (o.storagePushConstant8)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceDriverProperties(const char* s, Json::Value& obj, VkPhysicalDeviceDriverProperties& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceDriverProperties*)parsePNextChain(obj); + + parse_VkDriverId("driverID", obj["driverID"], (o.driverID)); + + /** TODO: Handle this - driverName **/ + + /** TODO: Handle this - driverInfo **/ + + parse_VkConformanceVersion("conformanceVersion", obj["conformanceVersion"], (o.conformanceVersion)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceShaderAtomicInt64Features(const char* s, Json::Value& obj, VkPhysicalDeviceShaderAtomicInt64Features& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceShaderAtomicInt64Features*)parsePNextChain(obj); + + parse_VkBool32("shaderBufferInt64Atomics", obj["shaderBufferInt64Atomics"], (o.shaderBufferInt64Atomics)); + + parse_VkBool32("shaderSharedInt64Atomics", obj["shaderSharedInt64Atomics"], (o.shaderSharedInt64Atomics)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceShaderFloat16Int8Features(const char* s, Json::Value& obj, VkPhysicalDeviceShaderFloat16Int8Features& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceShaderFloat16Int8Features*)parsePNextChain(obj); + + parse_VkBool32("shaderFloat16", obj["shaderFloat16"], (o.shaderFloat16)); + + parse_VkBool32("shaderInt8", obj["shaderInt8"], (o.shaderInt8)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceFloatControlsProperties(const char* s, Json::Value& obj, VkPhysicalDeviceFloatControlsProperties& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceFloatControlsProperties*)parsePNextChain(obj); + + parse_VkShaderFloatControlsIndependence("denormBehaviorIndependence", obj["denormBehaviorIndependence"], (o.denormBehaviorIndependence)); + + parse_VkShaderFloatControlsIndependence("roundingModeIndependence", obj["roundingModeIndependence"], (o.roundingModeIndependence)); + + parse_VkBool32("shaderSignedZeroInfNanPreserveFloat16", obj["shaderSignedZeroInfNanPreserveFloat16"], (o.shaderSignedZeroInfNanPreserveFloat16)); + + parse_VkBool32("shaderSignedZeroInfNanPreserveFloat32", obj["shaderSignedZeroInfNanPreserveFloat32"], (o.shaderSignedZeroInfNanPreserveFloat32)); + + parse_VkBool32("shaderSignedZeroInfNanPreserveFloat64", obj["shaderSignedZeroInfNanPreserveFloat64"], (o.shaderSignedZeroInfNanPreserveFloat64)); + + parse_VkBool32("shaderDenormPreserveFloat16", obj["shaderDenormPreserveFloat16"], (o.shaderDenormPreserveFloat16)); + + parse_VkBool32("shaderDenormPreserveFloat32", obj["shaderDenormPreserveFloat32"], (o.shaderDenormPreserveFloat32)); + + parse_VkBool32("shaderDenormPreserveFloat64", obj["shaderDenormPreserveFloat64"], (o.shaderDenormPreserveFloat64)); + + parse_VkBool32("shaderDenormFlushToZeroFloat16", obj["shaderDenormFlushToZeroFloat16"], (o.shaderDenormFlushToZeroFloat16)); + + parse_VkBool32("shaderDenormFlushToZeroFloat32", obj["shaderDenormFlushToZeroFloat32"], (o.shaderDenormFlushToZeroFloat32)); + + parse_VkBool32("shaderDenormFlushToZeroFloat64", obj["shaderDenormFlushToZeroFloat64"], (o.shaderDenormFlushToZeroFloat64)); + + parse_VkBool32("shaderRoundingModeRTEFloat16", obj["shaderRoundingModeRTEFloat16"], (o.shaderRoundingModeRTEFloat16)); + + parse_VkBool32("shaderRoundingModeRTEFloat32", obj["shaderRoundingModeRTEFloat32"], (o.shaderRoundingModeRTEFloat32)); + + parse_VkBool32("shaderRoundingModeRTEFloat64", obj["shaderRoundingModeRTEFloat64"], (o.shaderRoundingModeRTEFloat64)); + + parse_VkBool32("shaderRoundingModeRTZFloat16", obj["shaderRoundingModeRTZFloat16"], (o.shaderRoundingModeRTZFloat16)); + + parse_VkBool32("shaderRoundingModeRTZFloat32", obj["shaderRoundingModeRTZFloat32"], (o.shaderRoundingModeRTZFloat32)); + + parse_VkBool32("shaderRoundingModeRTZFloat64", obj["shaderRoundingModeRTZFloat64"], (o.shaderRoundingModeRTZFloat64)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkDescriptorSetLayoutBindingFlagsCreateInfo(const char* s, Json::Value& obj, VkDescriptorSetLayoutBindingFlagsCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDescriptorSetLayoutBindingFlagsCreateInfo*)parsePNextChain(obj); + + parse_uint32_t("bindingCount", obj["bindingCount"], (o.bindingCount)); + + (o.pBindingFlags) = (VkDescriptorBindingFlags*)s_globalMem.allocate((o.bindingCount), sizeof(VkDescriptorBindingFlags)); + Json::Value& obj_pBindingFlags_arr = obj["pBindingFlags"]; + for (unsigned int i = 0; i < obj_pBindingFlags_arr.size(); i++) { + parse_VkDescriptorBindingFlags("pBindingFlags", obj_pBindingFlags_arr[i], const_cast((o.pBindingFlags[i]))); + } + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceDescriptorIndexingFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceDescriptorIndexingFeatures& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceDescriptorIndexingFeatures*)parsePNextChain(obj); + + parse_VkBool32("shaderInputAttachmentArrayDynamicIndexing", obj["shaderInputAttachmentArrayDynamicIndexing"], (o.shaderInputAttachmentArrayDynamicIndexing)); + + parse_VkBool32("shaderUniformTexelBufferArrayDynamicIndexing", obj["shaderUniformTexelBufferArrayDynamicIndexing"], (o.shaderUniformTexelBufferArrayDynamicIndexing)); + + parse_VkBool32("shaderStorageTexelBufferArrayDynamicIndexing", obj["shaderStorageTexelBufferArrayDynamicIndexing"], (o.shaderStorageTexelBufferArrayDynamicIndexing)); + + parse_VkBool32("shaderUniformBufferArrayNonUniformIndexing", obj["shaderUniformBufferArrayNonUniformIndexing"], (o.shaderUniformBufferArrayNonUniformIndexing)); + + parse_VkBool32("shaderSampledImageArrayNonUniformIndexing", obj["shaderSampledImageArrayNonUniformIndexing"], (o.shaderSampledImageArrayNonUniformIndexing)); + + parse_VkBool32("shaderStorageBufferArrayNonUniformIndexing", obj["shaderStorageBufferArrayNonUniformIndexing"], (o.shaderStorageBufferArrayNonUniformIndexing)); + + parse_VkBool32("shaderStorageImageArrayNonUniformIndexing", obj["shaderStorageImageArrayNonUniformIndexing"], (o.shaderStorageImageArrayNonUniformIndexing)); + + parse_VkBool32("shaderInputAttachmentArrayNonUniformIndexing", obj["shaderInputAttachmentArrayNonUniformIndexing"], (o.shaderInputAttachmentArrayNonUniformIndexing)); + + parse_VkBool32("shaderUniformTexelBufferArrayNonUniformIndexing", obj["shaderUniformTexelBufferArrayNonUniformIndexing"], (o.shaderUniformTexelBufferArrayNonUniformIndexing)); + + parse_VkBool32("shaderStorageTexelBufferArrayNonUniformIndexing", obj["shaderStorageTexelBufferArrayNonUniformIndexing"], (o.shaderStorageTexelBufferArrayNonUniformIndexing)); + + parse_VkBool32("descriptorBindingUniformBufferUpdateAfterBind", obj["descriptorBindingUniformBufferUpdateAfterBind"], (o.descriptorBindingUniformBufferUpdateAfterBind)); + + parse_VkBool32("descriptorBindingSampledImageUpdateAfterBind", obj["descriptorBindingSampledImageUpdateAfterBind"], (o.descriptorBindingSampledImageUpdateAfterBind)); + + parse_VkBool32("descriptorBindingStorageImageUpdateAfterBind", obj["descriptorBindingStorageImageUpdateAfterBind"], (o.descriptorBindingStorageImageUpdateAfterBind)); + + parse_VkBool32("descriptorBindingStorageBufferUpdateAfterBind", obj["descriptorBindingStorageBufferUpdateAfterBind"], (o.descriptorBindingStorageBufferUpdateAfterBind)); + + parse_VkBool32("descriptorBindingUniformTexelBufferUpdateAfterBind", obj["descriptorBindingUniformTexelBufferUpdateAfterBind"], (o.descriptorBindingUniformTexelBufferUpdateAfterBind)); + + parse_VkBool32("descriptorBindingStorageTexelBufferUpdateAfterBind", obj["descriptorBindingStorageTexelBufferUpdateAfterBind"], (o.descriptorBindingStorageTexelBufferUpdateAfterBind)); + + parse_VkBool32("descriptorBindingUpdateUnusedWhilePending", obj["descriptorBindingUpdateUnusedWhilePending"], (o.descriptorBindingUpdateUnusedWhilePending)); + + parse_VkBool32("descriptorBindingPartiallyBound", obj["descriptorBindingPartiallyBound"], (o.descriptorBindingPartiallyBound)); + + parse_VkBool32("descriptorBindingVariableDescriptorCount", obj["descriptorBindingVariableDescriptorCount"], (o.descriptorBindingVariableDescriptorCount)); + + parse_VkBool32("runtimeDescriptorArray", obj["runtimeDescriptorArray"], (o.runtimeDescriptorArray)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceDescriptorIndexingProperties(const char* s, Json::Value& obj, VkPhysicalDeviceDescriptorIndexingProperties& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceDescriptorIndexingProperties*)parsePNextChain(obj); + + parse_uint32_t("maxUpdateAfterBindDescriptorsInAllPools", obj["maxUpdateAfterBindDescriptorsInAllPools"], (o.maxUpdateAfterBindDescriptorsInAllPools)); + + parse_VkBool32("shaderUniformBufferArrayNonUniformIndexingNative", obj["shaderUniformBufferArrayNonUniformIndexingNative"], (o.shaderUniformBufferArrayNonUniformIndexingNative)); + + parse_VkBool32("shaderSampledImageArrayNonUniformIndexingNative", obj["shaderSampledImageArrayNonUniformIndexingNative"], (o.shaderSampledImageArrayNonUniformIndexingNative)); + + parse_VkBool32("shaderStorageBufferArrayNonUniformIndexingNative", obj["shaderStorageBufferArrayNonUniformIndexingNative"], (o.shaderStorageBufferArrayNonUniformIndexingNative)); + + parse_VkBool32("shaderStorageImageArrayNonUniformIndexingNative", obj["shaderStorageImageArrayNonUniformIndexingNative"], (o.shaderStorageImageArrayNonUniformIndexingNative)); + + parse_VkBool32("shaderInputAttachmentArrayNonUniformIndexingNative", obj["shaderInputAttachmentArrayNonUniformIndexingNative"], (o.shaderInputAttachmentArrayNonUniformIndexingNative)); + + parse_VkBool32("robustBufferAccessUpdateAfterBind", obj["robustBufferAccessUpdateAfterBind"], (o.robustBufferAccessUpdateAfterBind)); + + parse_VkBool32("quadDivergentImplicitLod", obj["quadDivergentImplicitLod"], (o.quadDivergentImplicitLod)); + + parse_uint32_t("maxPerStageDescriptorUpdateAfterBindSamplers", obj["maxPerStageDescriptorUpdateAfterBindSamplers"], (o.maxPerStageDescriptorUpdateAfterBindSamplers)); + + parse_uint32_t("maxPerStageDescriptorUpdateAfterBindUniformBuffers", obj["maxPerStageDescriptorUpdateAfterBindUniformBuffers"], (o.maxPerStageDescriptorUpdateAfterBindUniformBuffers)); + + parse_uint32_t("maxPerStageDescriptorUpdateAfterBindStorageBuffers", obj["maxPerStageDescriptorUpdateAfterBindStorageBuffers"], (o.maxPerStageDescriptorUpdateAfterBindStorageBuffers)); + + parse_uint32_t("maxPerStageDescriptorUpdateAfterBindSampledImages", obj["maxPerStageDescriptorUpdateAfterBindSampledImages"], (o.maxPerStageDescriptorUpdateAfterBindSampledImages)); + + parse_uint32_t("maxPerStageDescriptorUpdateAfterBindStorageImages", obj["maxPerStageDescriptorUpdateAfterBindStorageImages"], (o.maxPerStageDescriptorUpdateAfterBindStorageImages)); + + parse_uint32_t("maxPerStageDescriptorUpdateAfterBindInputAttachments", obj["maxPerStageDescriptorUpdateAfterBindInputAttachments"], (o.maxPerStageDescriptorUpdateAfterBindInputAttachments)); + + parse_uint32_t("maxPerStageUpdateAfterBindResources", obj["maxPerStageUpdateAfterBindResources"], (o.maxPerStageUpdateAfterBindResources)); + + parse_uint32_t("maxDescriptorSetUpdateAfterBindSamplers", obj["maxDescriptorSetUpdateAfterBindSamplers"], (o.maxDescriptorSetUpdateAfterBindSamplers)); + + parse_uint32_t("maxDescriptorSetUpdateAfterBindUniformBuffers", obj["maxDescriptorSetUpdateAfterBindUniformBuffers"], (o.maxDescriptorSetUpdateAfterBindUniformBuffers)); + + parse_uint32_t("maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", obj["maxDescriptorSetUpdateAfterBindUniformBuffersDynamic"], (o.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic)); + + parse_uint32_t("maxDescriptorSetUpdateAfterBindStorageBuffers", obj["maxDescriptorSetUpdateAfterBindStorageBuffers"], (o.maxDescriptorSetUpdateAfterBindStorageBuffers)); + + parse_uint32_t("maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", obj["maxDescriptorSetUpdateAfterBindStorageBuffersDynamic"], (o.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic)); + + parse_uint32_t("maxDescriptorSetUpdateAfterBindSampledImages", obj["maxDescriptorSetUpdateAfterBindSampledImages"], (o.maxDescriptorSetUpdateAfterBindSampledImages)); + + parse_uint32_t("maxDescriptorSetUpdateAfterBindStorageImages", obj["maxDescriptorSetUpdateAfterBindStorageImages"], (o.maxDescriptorSetUpdateAfterBindStorageImages)); + + parse_uint32_t("maxDescriptorSetUpdateAfterBindInputAttachments", obj["maxDescriptorSetUpdateAfterBindInputAttachments"], (o.maxDescriptorSetUpdateAfterBindInputAttachments)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkDescriptorSetVariableDescriptorCountAllocateInfo(const char* s, Json::Value& obj, VkDescriptorSetVariableDescriptorCountAllocateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDescriptorSetVariableDescriptorCountAllocateInfo*)parsePNextChain(obj); + + parse_uint32_t("descriptorSetCount", obj["descriptorSetCount"], (o.descriptorSetCount)); + + (o.pDescriptorCounts) = (uint32_t*)s_globalMem.allocate((o.descriptorSetCount), sizeof(uint32_t)); + Json::Value& obj_pDescriptorCounts_arr = obj["pDescriptorCounts"]; + for (unsigned int i = 0; i < obj_pDescriptorCounts_arr.size(); i++) { + parse_uint32_t("pDescriptorCounts", obj_pDescriptorCounts_arr[i], const_cast((o.pDescriptorCounts[i]))); + } + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkDescriptorSetVariableDescriptorCountLayoutSupport(const char* s, Json::Value& obj, VkDescriptorSetVariableDescriptorCountLayoutSupport& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDescriptorSetVariableDescriptorCountLayoutSupport*)parsePNextChain(obj); + + parse_uint32_t("maxVariableDescriptorCount", obj["maxVariableDescriptorCount"], (o.maxVariableDescriptorCount)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkSubpassDescriptionDepthStencilResolve(const char* s, Json::Value& obj, VkSubpassDescriptionDepthStencilResolve& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSubpassDescriptionDepthStencilResolve*)parsePNextChain(obj); + + parse_VkResolveModeFlagBits("depthResolveMode", obj["depthResolveMode"], (o.depthResolveMode)); + + parse_VkResolveModeFlagBits("stencilResolveMode", obj["stencilResolveMode"], (o.stencilResolveMode)); + + { + Json::Value& obj_pDepthStencilResolveAttachment = obj["pDepthStencilResolveAttachment"]; + const int sz = obj_pDepthStencilResolveAttachment.size(); + if (obj_pDepthStencilResolveAttachment.size() == 0) { + (o.pDepthStencilResolveAttachment) = nullptr; + } else { + (o.pDepthStencilResolveAttachment) = (VkAttachmentReference2*)s_globalMem.allocate(1, sizeof(VkAttachmentReference2)); + parse_VkAttachmentReference2("pDepthStencilResolveAttachment", obj_pDepthStencilResolveAttachment, const_cast(*(o.pDepthStencilResolveAttachment))); + } + } + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceDepthStencilResolveProperties(const char* s, Json::Value& obj, VkPhysicalDeviceDepthStencilResolveProperties& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceDepthStencilResolveProperties*)parsePNextChain(obj); + + parse_VkResolveModeFlags("supportedDepthResolveModes", obj["supportedDepthResolveModes"], (o.supportedDepthResolveModes)); + + parse_VkResolveModeFlags("supportedStencilResolveModes", obj["supportedStencilResolveModes"], (o.supportedStencilResolveModes)); + + parse_VkBool32("independentResolveNone", obj["independentResolveNone"], (o.independentResolveNone)); + + parse_VkBool32("independentResolve", obj["independentResolve"], (o.independentResolve)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceScalarBlockLayoutFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceScalarBlockLayoutFeatures& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceScalarBlockLayoutFeatures*)parsePNextChain(obj); + + parse_VkBool32("scalarBlockLayout", obj["scalarBlockLayout"], (o.scalarBlockLayout)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkImageStencilUsageCreateInfo(const char* s, Json::Value& obj, VkImageStencilUsageCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImageStencilUsageCreateInfo*)parsePNextChain(obj); + + parse_VkImageUsageFlags("stencilUsage", obj["stencilUsage"], (o.stencilUsage)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkSamplerReductionModeCreateInfo(const char* s, Json::Value& obj, VkSamplerReductionModeCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSamplerReductionModeCreateInfo*)parsePNextChain(obj); + + parse_VkSamplerReductionMode("reductionMode", obj["reductionMode"], (o.reductionMode)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceSamplerFilterMinmaxProperties(const char* s, Json::Value& obj, VkPhysicalDeviceSamplerFilterMinmaxProperties& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceSamplerFilterMinmaxProperties*)parsePNextChain(obj); + + parse_VkBool32("filterMinmaxSingleComponentFormats", obj["filterMinmaxSingleComponentFormats"], (o.filterMinmaxSingleComponentFormats)); + + parse_VkBool32("filterMinmaxImageComponentMapping", obj["filterMinmaxImageComponentMapping"], (o.filterMinmaxImageComponentMapping)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceVulkanMemoryModelFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceVulkanMemoryModelFeatures& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceVulkanMemoryModelFeatures*)parsePNextChain(obj); + + parse_VkBool32("vulkanMemoryModel", obj["vulkanMemoryModel"], (o.vulkanMemoryModel)); + + parse_VkBool32("vulkanMemoryModelDeviceScope", obj["vulkanMemoryModelDeviceScope"], (o.vulkanMemoryModelDeviceScope)); + + parse_VkBool32("vulkanMemoryModelAvailabilityVisibilityChains", obj["vulkanMemoryModelAvailabilityVisibilityChains"], (o.vulkanMemoryModelAvailabilityVisibilityChains)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceImagelessFramebufferFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceImagelessFramebufferFeatures& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceImagelessFramebufferFeatures*)parsePNextChain(obj); + + parse_VkBool32("imagelessFramebuffer", obj["imagelessFramebuffer"], (o.imagelessFramebuffer)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkFramebufferAttachmentImageInfo(const char* s, Json::Value& obj, VkFramebufferAttachmentImageInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkFramebufferAttachmentImageInfo*)parsePNextChain(obj); + + parse_VkImageCreateFlags("flags", obj["flags"], (o.flags)); + + parse_VkImageUsageFlags("usage", obj["usage"], (o.usage)); + + parse_uint32_t("width", obj["width"], (o.width)); + + parse_uint32_t("height", obj["height"], (o.height)); + + parse_uint32_t("layerCount", obj["layerCount"], (o.layerCount)); + + parse_uint32_t("viewFormatCount", obj["viewFormatCount"], (o.viewFormatCount)); + + (o.pViewFormats) = (VkFormat*)s_globalMem.allocate((o.viewFormatCount), sizeof(VkFormat)); + Json::Value& obj_pViewFormats_arr = obj["pViewFormats"]; + for (unsigned int i = 0; i < obj_pViewFormats_arr.size(); i++) { + parse_VkFormat("pViewFormats", obj_pViewFormats_arr[i], const_cast((o.pViewFormats[i]))); + } + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkFramebufferAttachmentsCreateInfo(const char* s, Json::Value& obj, VkFramebufferAttachmentsCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkFramebufferAttachmentsCreateInfo*)parsePNextChain(obj); + + parse_uint32_t("attachmentImageInfoCount", obj["attachmentImageInfoCount"], (o.attachmentImageInfoCount)); + + (o.pAttachmentImageInfos) = (VkFramebufferAttachmentImageInfo*)s_globalMem.allocate((o.attachmentImageInfoCount), sizeof(VkFramebufferAttachmentImageInfo)); + Json::Value& obj_pAttachmentImageInfos = obj["pAttachmentImageInfos"]; + if (obj_pAttachmentImageInfos.size() == 0) (o.pAttachmentImageInfos) = nullptr; + else { + for (unsigned int i = 0; i < (o.attachmentImageInfoCount); i++) { + parse_VkFramebufferAttachmentImageInfo("pAttachmentImageInfos", obj_pAttachmentImageInfos[i], const_cast((o.pAttachmentImageInfos[i]))); + } + } + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkRenderPassAttachmentBeginInfo(const char* s, Json::Value& obj, VkRenderPassAttachmentBeginInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkRenderPassAttachmentBeginInfo*)parsePNextChain(obj); + + parse_uint32_t("attachmentCount", obj["attachmentCount"], (o.attachmentCount)); + + (o.pAttachments) = (VkImageView*)s_globalMem.allocate((o.attachmentCount), sizeof(VkImageView)); + Json::Value& obj_pAttachments_arr = obj["pAttachments"]; + for (unsigned int i = 0; i < obj_pAttachments_arr.size(); i++) { + parse_VkImageView("pAttachments", obj_pAttachments_arr[i], const_cast((o.pAttachments[i]))); + } + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceUniformBufferStandardLayoutFeatures& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceUniformBufferStandardLayoutFeatures*)parsePNextChain(obj); + + parse_VkBool32("uniformBufferStandardLayout", obj["uniformBufferStandardLayout"], (o.uniformBufferStandardLayout)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*)parsePNextChain(obj); + + parse_VkBool32("shaderSubgroupExtendedTypes", obj["shaderSubgroupExtendedTypes"], (o.shaderSubgroupExtendedTypes)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*)parsePNextChain(obj); + + parse_VkBool32("separateDepthStencilLayouts", obj["separateDepthStencilLayouts"], (o.separateDepthStencilLayouts)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkAttachmentReferenceStencilLayout(const char* s, Json::Value& obj, VkAttachmentReferenceStencilLayout& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkAttachmentReferenceStencilLayout*)parsePNextChain(obj); + + parse_VkImageLayout("stencilLayout", obj["stencilLayout"], (o.stencilLayout)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkAttachmentDescriptionStencilLayout(const char* s, Json::Value& obj, VkAttachmentDescriptionStencilLayout& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkAttachmentDescriptionStencilLayout*)parsePNextChain(obj); + + parse_VkImageLayout("stencilInitialLayout", obj["stencilInitialLayout"], (o.stencilInitialLayout)); + + parse_VkImageLayout("stencilFinalLayout", obj["stencilFinalLayout"], (o.stencilFinalLayout)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceHostQueryResetFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceHostQueryResetFeatures& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceHostQueryResetFeatures*)parsePNextChain(obj); + + parse_VkBool32("hostQueryReset", obj["hostQueryReset"], (o.hostQueryReset)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceTimelineSemaphoreFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceTimelineSemaphoreFeatures& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceTimelineSemaphoreFeatures*)parsePNextChain(obj); + + parse_VkBool32("timelineSemaphore", obj["timelineSemaphore"], (o.timelineSemaphore)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceTimelineSemaphoreProperties(const char* s, Json::Value& obj, VkPhysicalDeviceTimelineSemaphoreProperties& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceTimelineSemaphoreProperties*)parsePNextChain(obj); + + parse_uint64_t("maxTimelineSemaphoreValueDifference", obj["maxTimelineSemaphoreValueDifference"], (o.maxTimelineSemaphoreValueDifference)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkSemaphoreTypeCreateInfo(const char* s, Json::Value& obj, VkSemaphoreTypeCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSemaphoreTypeCreateInfo*)parsePNextChain(obj); + + parse_VkSemaphoreType("semaphoreType", obj["semaphoreType"], (o.semaphoreType)); + + parse_uint64_t("initialValue", obj["initialValue"], (o.initialValue)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkTimelineSemaphoreSubmitInfo(const char* s, Json::Value& obj, VkTimelineSemaphoreSubmitInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkTimelineSemaphoreSubmitInfo*)parsePNextChain(obj); + + parse_uint32_t("waitSemaphoreValueCount", obj["waitSemaphoreValueCount"], (o.waitSemaphoreValueCount)); + + + parse_uint32_t("signalSemaphoreValueCount", obj["signalSemaphoreValueCount"], (o.signalSemaphoreValueCount)); + + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkSemaphoreWaitInfo(const char* s, Json::Value& obj, VkSemaphoreWaitInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSemaphoreWaitInfo*)parsePNextChain(obj); + + parse_VkSemaphoreWaitFlags("flags", obj["flags"], (o.flags)); + + parse_uint32_t("semaphoreCount", obj["semaphoreCount"], (o.semaphoreCount)); + + (o.pSemaphores) = (VkSemaphore*)s_globalMem.allocate((o.semaphoreCount), sizeof(VkSemaphore)); + Json::Value& obj_pSemaphores_arr = obj["pSemaphores"]; + for (unsigned int i = 0; i < obj_pSemaphores_arr.size(); i++) { + parse_VkSemaphore("pSemaphores", obj_pSemaphores_arr[i], const_cast((o.pSemaphores[i]))); + } + + (o.pValues) = (uint64_t*)s_globalMem.allocate((o.semaphoreCount), sizeof(uint64_t)); + Json::Value& obj_pValues_arr = obj["pValues"]; + for (unsigned int i = 0; i < obj_pValues_arr.size(); i++) { + parse_uint64_t("pValues", obj_pValues_arr[i], const_cast((o.pValues[i]))); + } + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkSemaphoreSignalInfo(const char* s, Json::Value& obj, VkSemaphoreSignalInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSemaphoreSignalInfo*)parsePNextChain(obj); + + + parse_uint64_t("value", obj["value"], (o.value)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkPhysicalDeviceBufferDeviceAddressFeatures(const char* s, Json::Value& obj, VkPhysicalDeviceBufferDeviceAddressFeatures& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceBufferDeviceAddressFeatures*)parsePNextChain(obj); + + parse_VkBool32("bufferDeviceAddress", obj["bufferDeviceAddress"], (o.bufferDeviceAddress)); + + parse_VkBool32("bufferDeviceAddressCaptureReplay", obj["bufferDeviceAddressCaptureReplay"], (o.bufferDeviceAddressCaptureReplay)); + + parse_VkBool32("bufferDeviceAddressMultiDevice", obj["bufferDeviceAddressMultiDevice"], (o.bufferDeviceAddressMultiDevice)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkBufferDeviceAddressInfo(const char* s, Json::Value& obj, VkBufferDeviceAddressInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkBufferDeviceAddressInfo*)parsePNextChain(obj); + + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkBufferOpaqueCaptureAddressCreateInfo(const char* s, Json::Value& obj, VkBufferOpaqueCaptureAddressCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkBufferOpaqueCaptureAddressCreateInfo*)parsePNextChain(obj); + + parse_uint64_t("opaqueCaptureAddress", obj["opaqueCaptureAddress"], (o.opaqueCaptureAddress)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkMemoryOpaqueCaptureAddressAllocateInfo(const char* s, Json::Value& obj, VkMemoryOpaqueCaptureAddressAllocateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkMemoryOpaqueCaptureAddressAllocateInfo*)parsePNextChain(obj); + + parse_uint64_t("opaqueCaptureAddress", obj["opaqueCaptureAddress"], (o.opaqueCaptureAddress)); + +} +#endif + +#ifdef VK_VERSION_1_2 +static void parse_VkDeviceMemoryOpaqueCaptureAddressInfo(const char* s, Json::Value& obj, VkDeviceMemoryOpaqueCaptureAddressInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDeviceMemoryOpaqueCaptureAddressInfo*)parsePNextChain(obj); + + +} +#endif + +#ifdef VKSC_VERSION_1_0 +static std::map VkFaultLevel_map = { + std::make_pair("VK_FAULT_LEVEL_UNASSIGNED", 0), + std::make_pair("VK_FAULT_LEVEL_CRITICAL", 1), + std::make_pair("VK_FAULT_LEVEL_RECOVERABLE", 2), + std::make_pair("VK_FAULT_LEVEL_WARNING", 3), +}; +static void parse_VkFaultLevel(const char* s, Json::Value& obj, VkFaultLevel& o) { + std::string _res = obj.asString(); + o = (VkFaultLevel)VkFaultLevel_map[std::string(_res)]; +} +#endif + +#ifdef VKSC_VERSION_1_0 +static std::map VkFaultType_map = { + std::make_pair("VK_FAULT_TYPE_INVALID", 0), + std::make_pair("VK_FAULT_TYPE_UNASSIGNED", 1), + std::make_pair("VK_FAULT_TYPE_IMPLEMENTATION", 2), + std::make_pair("VK_FAULT_TYPE_SYSTEM", 3), + std::make_pair("VK_FAULT_TYPE_PHYSICAL_DEVICE", 4), + std::make_pair("VK_FAULT_TYPE_COMMAND_BUFFER_FULL", 5), + std::make_pair("VK_FAULT_TYPE_INVALID_API_USAGE", 6), +}; +static void parse_VkFaultType(const char* s, Json::Value& obj, VkFaultType& o) { + std::string _res = obj.asString(); + o = (VkFaultType)VkFaultType_map[std::string(_res)]; +} +#endif + +#ifdef VKSC_VERSION_1_0 +static std::map VkFaultQueryBehavior_map = { + std::make_pair("VK_FAULT_QUERY_BEHAVIOR_GET_AND_CLEAR_ALL_FAULTS", 0), +}; +static void parse_VkFaultQueryBehavior(const char* s, Json::Value& obj, VkFaultQueryBehavior& o) { + std::string _res = obj.asString(); + o = (VkFaultQueryBehavior)VkFaultQueryBehavior_map[std::string(_res)]; +} +#endif + +#ifdef VKSC_VERSION_1_0 +static std::map VkPipelineMatchControl_map = { + std::make_pair("VK_PIPELINE_MATCH_CONTROL_APPLICATION_UUID_EXACT_MATCH", 0), +}; +static void parse_VkPipelineMatchControl(const char* s, Json::Value& obj, VkPipelineMatchControl& o) { + std::string _res = obj.asString(); + o = (VkPipelineMatchControl)VkPipelineMatchControl_map[std::string(_res)]; +} +#endif + +#ifdef VKSC_VERSION_1_0 +static std::map VkPipelineCacheValidationVersion_map = { + std::make_pair("VK_PIPELINE_CACHE_VALIDATION_VERSION_SAFETY_CRITICAL_ONE", 1), +}; +static void parse_VkPipelineCacheValidationVersion(const char* s, Json::Value& obj, VkPipelineCacheValidationVersion& o) { + std::string _res = obj.asString(); + o = (VkPipelineCacheValidationVersion)VkPipelineCacheValidationVersion_map[std::string(_res)]; +} +#endif + +#ifdef VKSC_VERSION_1_0 +static void parse_VkPhysicalDeviceVulkanSC10Features(const char* s, Json::Value& obj, VkPhysicalDeviceVulkanSC10Features& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceVulkanSC10Features*)parsePNextChain(obj); + + parse_VkBool32("shaderAtomicInstructions", obj["shaderAtomicInstructions"], (o.shaderAtomicInstructions)); + +} +#endif + +#ifdef VKSC_VERSION_1_0 +static void parse_VkPhysicalDeviceVulkanSC10Properties(const char* s, Json::Value& obj, VkPhysicalDeviceVulkanSC10Properties& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceVulkanSC10Properties*)parsePNextChain(obj); + + parse_VkBool32("deviceNoDynamicHostAllocations", obj["deviceNoDynamicHostAllocations"], (o.deviceNoDynamicHostAllocations)); + + parse_VkBool32("deviceDestroyFreesMemory", obj["deviceDestroyFreesMemory"], (o.deviceDestroyFreesMemory)); + + parse_VkBool32("commandPoolMultipleCommandBuffersRecording", obj["commandPoolMultipleCommandBuffersRecording"], (o.commandPoolMultipleCommandBuffersRecording)); + + parse_VkBool32("commandPoolResetCommandBuffer", obj["commandPoolResetCommandBuffer"], (o.commandPoolResetCommandBuffer)); + + parse_VkBool32("commandBufferSimultaneousUse", obj["commandBufferSimultaneousUse"], (o.commandBufferSimultaneousUse)); + + parse_VkBool32("secondaryCommandBufferNullOrImagelessFramebuffer", obj["secondaryCommandBufferNullOrImagelessFramebuffer"], (o.secondaryCommandBufferNullOrImagelessFramebuffer)); + + parse_VkBool32("recycleDescriptorSetMemory", obj["recycleDescriptorSetMemory"], (o.recycleDescriptorSetMemory)); + + parse_VkBool32("recyclePipelineMemory", obj["recyclePipelineMemory"], (o.recyclePipelineMemory)); + + parse_uint32_t("maxRenderPassSubpasses", obj["maxRenderPassSubpasses"], (o.maxRenderPassSubpasses)); + + parse_uint32_t("maxRenderPassDependencies", obj["maxRenderPassDependencies"], (o.maxRenderPassDependencies)); + + parse_uint32_t("maxSubpassInputAttachments", obj["maxSubpassInputAttachments"], (o.maxSubpassInputAttachments)); + + parse_uint32_t("maxSubpassPreserveAttachments", obj["maxSubpassPreserveAttachments"], (o.maxSubpassPreserveAttachments)); + + parse_uint32_t("maxFramebufferAttachments", obj["maxFramebufferAttachments"], (o.maxFramebufferAttachments)); + + parse_uint32_t("maxDescriptorSetLayoutBindings", obj["maxDescriptorSetLayoutBindings"], (o.maxDescriptorSetLayoutBindings)); + + parse_uint32_t("maxQueryFaultCount", obj["maxQueryFaultCount"], (o.maxQueryFaultCount)); + + parse_uint32_t("maxCallbackFaultCount", obj["maxCallbackFaultCount"], (o.maxCallbackFaultCount)); + + parse_uint32_t("maxCommandPoolCommandBuffers", obj["maxCommandPoolCommandBuffers"], (o.maxCommandPoolCommandBuffers)); + + parse_VkDeviceSize("maxCommandBufferSize", obj["maxCommandBufferSize"], (o.maxCommandBufferSize)); + +} +#endif + +#ifdef VKSC_VERSION_1_0 +static void parse_VkPipelinePoolSize(const char* s, Json::Value& obj, VkPipelinePoolSize& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelinePoolSize*)parsePNextChain(obj); + + parse_VkDeviceSize("poolEntrySize", obj["poolEntrySize"], (o.poolEntrySize)); + + parse_uint32_t("poolEntryCount", obj["poolEntryCount"], (o.poolEntryCount)); + +} +#endif + +#ifdef VKSC_VERSION_1_0 +static void parse_VkDeviceObjectReservationCreateInfo(const char* s, Json::Value& obj, VkDeviceObjectReservationCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDeviceObjectReservationCreateInfo*)parsePNextChain(obj); + + parse_uint32_t("pipelineCacheCreateInfoCount", obj["pipelineCacheCreateInfoCount"], (o.pipelineCacheCreateInfoCount)); + + (o.pPipelineCacheCreateInfos) = (VkPipelineCacheCreateInfo*)s_globalMem.allocate((o.pipelineCacheCreateInfoCount), sizeof(VkPipelineCacheCreateInfo)); + Json::Value& obj_pPipelineCacheCreateInfos = obj["pPipelineCacheCreateInfos"]; + if (obj_pPipelineCacheCreateInfos.size() == 0) (o.pPipelineCacheCreateInfos) = nullptr; + else { + for (unsigned int i = 0; i < (o.pipelineCacheCreateInfoCount); i++) { + parse_VkPipelineCacheCreateInfo("pPipelineCacheCreateInfos", obj_pPipelineCacheCreateInfos[i], const_cast((o.pPipelineCacheCreateInfos[i]))); + } + } + + parse_uint32_t("pipelinePoolSizeCount", obj["pipelinePoolSizeCount"], (o.pipelinePoolSizeCount)); + + (o.pPipelinePoolSizes) = (VkPipelinePoolSize*)s_globalMem.allocate((o.pipelinePoolSizeCount), sizeof(VkPipelinePoolSize)); + Json::Value& obj_pPipelinePoolSizes = obj["pPipelinePoolSizes"]; + if (obj_pPipelinePoolSizes.size() == 0) (o.pPipelinePoolSizes) = nullptr; + else { + for (unsigned int i = 0; i < (o.pipelinePoolSizeCount); i++) { + parse_VkPipelinePoolSize("pPipelinePoolSizes", obj_pPipelinePoolSizes[i], const_cast((o.pPipelinePoolSizes[i]))); + } + } + + parse_uint32_t("semaphoreRequestCount", obj["semaphoreRequestCount"], (o.semaphoreRequestCount)); + + parse_uint32_t("commandBufferRequestCount", obj["commandBufferRequestCount"], (o.commandBufferRequestCount)); + + parse_uint32_t("fenceRequestCount", obj["fenceRequestCount"], (o.fenceRequestCount)); + + parse_uint32_t("deviceMemoryRequestCount", obj["deviceMemoryRequestCount"], (o.deviceMemoryRequestCount)); + + parse_uint32_t("bufferRequestCount", obj["bufferRequestCount"], (o.bufferRequestCount)); + + parse_uint32_t("imageRequestCount", obj["imageRequestCount"], (o.imageRequestCount)); + + parse_uint32_t("eventRequestCount", obj["eventRequestCount"], (o.eventRequestCount)); + + parse_uint32_t("queryPoolRequestCount", obj["queryPoolRequestCount"], (o.queryPoolRequestCount)); + + parse_uint32_t("bufferViewRequestCount", obj["bufferViewRequestCount"], (o.bufferViewRequestCount)); + + parse_uint32_t("imageViewRequestCount", obj["imageViewRequestCount"], (o.imageViewRequestCount)); + + parse_uint32_t("layeredImageViewRequestCount", obj["layeredImageViewRequestCount"], (o.layeredImageViewRequestCount)); + + parse_uint32_t("pipelineCacheRequestCount", obj["pipelineCacheRequestCount"], (o.pipelineCacheRequestCount)); + + parse_uint32_t("pipelineLayoutRequestCount", obj["pipelineLayoutRequestCount"], (o.pipelineLayoutRequestCount)); + + parse_uint32_t("renderPassRequestCount", obj["renderPassRequestCount"], (o.renderPassRequestCount)); + + parse_uint32_t("graphicsPipelineRequestCount", obj["graphicsPipelineRequestCount"], (o.graphicsPipelineRequestCount)); + + parse_uint32_t("computePipelineRequestCount", obj["computePipelineRequestCount"], (o.computePipelineRequestCount)); + + parse_uint32_t("descriptorSetLayoutRequestCount", obj["descriptorSetLayoutRequestCount"], (o.descriptorSetLayoutRequestCount)); + + parse_uint32_t("samplerRequestCount", obj["samplerRequestCount"], (o.samplerRequestCount)); + + parse_uint32_t("descriptorPoolRequestCount", obj["descriptorPoolRequestCount"], (o.descriptorPoolRequestCount)); + + parse_uint32_t("descriptorSetRequestCount", obj["descriptorSetRequestCount"], (o.descriptorSetRequestCount)); + + parse_uint32_t("framebufferRequestCount", obj["framebufferRequestCount"], (o.framebufferRequestCount)); + + parse_uint32_t("commandPoolRequestCount", obj["commandPoolRequestCount"], (o.commandPoolRequestCount)); + + parse_uint32_t("samplerYcbcrConversionRequestCount", obj["samplerYcbcrConversionRequestCount"], (o.samplerYcbcrConversionRequestCount)); + + parse_uint32_t("surfaceRequestCount", obj["surfaceRequestCount"], (o.surfaceRequestCount)); + + parse_uint32_t("swapchainRequestCount", obj["swapchainRequestCount"], (o.swapchainRequestCount)); + + parse_uint32_t("displayModeRequestCount", obj["displayModeRequestCount"], (o.displayModeRequestCount)); + + parse_uint32_t("subpassDescriptionRequestCount", obj["subpassDescriptionRequestCount"], (o.subpassDescriptionRequestCount)); + + parse_uint32_t("attachmentDescriptionRequestCount", obj["attachmentDescriptionRequestCount"], (o.attachmentDescriptionRequestCount)); + + parse_uint32_t("descriptorSetLayoutBindingRequestCount", obj["descriptorSetLayoutBindingRequestCount"], (o.descriptorSetLayoutBindingRequestCount)); + + parse_uint32_t("descriptorSetLayoutBindingLimit", obj["descriptorSetLayoutBindingLimit"], (o.descriptorSetLayoutBindingLimit)); + + parse_uint32_t("maxImageViewMipLevels", obj["maxImageViewMipLevels"], (o.maxImageViewMipLevels)); + + parse_uint32_t("maxImageViewArrayLayers", obj["maxImageViewArrayLayers"], (o.maxImageViewArrayLayers)); + + parse_uint32_t("maxLayeredImageViewMipLevels", obj["maxLayeredImageViewMipLevels"], (o.maxLayeredImageViewMipLevels)); + + parse_uint32_t("maxOcclusionQueriesPerPool", obj["maxOcclusionQueriesPerPool"], (o.maxOcclusionQueriesPerPool)); + + parse_uint32_t("maxPipelineStatisticsQueriesPerPool", obj["maxPipelineStatisticsQueriesPerPool"], (o.maxPipelineStatisticsQueriesPerPool)); + + parse_uint32_t("maxTimestampQueriesPerPool", obj["maxTimestampQueriesPerPool"], (o.maxTimestampQueriesPerPool)); + + parse_uint32_t("maxImmutableSamplersPerDescriptorSetLayout", obj["maxImmutableSamplersPerDescriptorSetLayout"], (o.maxImmutableSamplersPerDescriptorSetLayout)); + +} +#endif + +#ifdef VKSC_VERSION_1_0 +static void parse_VkCommandPoolMemoryReservationCreateInfo(const char* s, Json::Value& obj, VkCommandPoolMemoryReservationCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkCommandPoolMemoryReservationCreateInfo*)parsePNextChain(obj); + + parse_VkDeviceSize("commandPoolReservedSize", obj["commandPoolReservedSize"], (o.commandPoolReservedSize)); + + parse_uint32_t("commandPoolMaxCommandBuffers", obj["commandPoolMaxCommandBuffers"], (o.commandPoolMaxCommandBuffers)); + +} +#endif + +#ifdef VKSC_VERSION_1_0 +static void parse_VkCommandPoolMemoryConsumption(const char* s, Json::Value& obj, VkCommandPoolMemoryConsumption& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkCommandPoolMemoryConsumption*)parsePNextChain(obj); + + parse_VkDeviceSize("commandPoolAllocated", obj["commandPoolAllocated"], (o.commandPoolAllocated)); + + parse_VkDeviceSize("commandPoolReservedSize", obj["commandPoolReservedSize"], (o.commandPoolReservedSize)); + + parse_VkDeviceSize("commandBufferAllocated", obj["commandBufferAllocated"], (o.commandBufferAllocated)); + +} +#endif + +#ifdef VKSC_VERSION_1_0 +static void parse_VkFaultData(const char* s, Json::Value& obj, VkFaultData& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkFaultData*)parsePNextChain(obj); + + parse_VkFaultLevel("faultLevel", obj["faultLevel"], (o.faultLevel)); + + parse_VkFaultType("faultType", obj["faultType"], (o.faultType)); + +} +#endif + +#ifdef VKSC_VERSION_1_0 +static void parse_VkFaultCallbackInfo(const char* s, Json::Value& obj, VkFaultCallbackInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkFaultCallbackInfo*)parsePNextChain(obj); + + parse_uint32_t("faultCount", obj["faultCount"], (o.faultCount)); + + (o.pFaults) = (VkFaultData*)s_globalMem.allocate((o.faultCount), sizeof(VkFaultData)); + Json::Value& obj_pFaults = obj["pFaults"]; + if (obj_pFaults.size() == 0) (o.pFaults) = nullptr; + else { + for (unsigned int i = 0; i < (o.faultCount); i++) { + parse_VkFaultData("pFaults", obj_pFaults[i], const_cast((o.pFaults[i]))); + } + } + + /** Note: Ignoring function pointer (PFN_vkFaultCallbackFunction). **/ + +} +#endif + +#ifdef VKSC_VERSION_1_0 +static void parse_VkPipelineOfflineCreateInfo(const char* s, Json::Value& obj, VkPipelineOfflineCreateInfo& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineOfflineCreateInfo*)parsePNextChain(obj); + + Json::Value& obj_pipelineIdentifier_arr = obj["pipelineIdentifier"]; + for (unsigned int i = 0; i < obj_pipelineIdentifier_arr.size(); i++) { + parse_uint8_t("pipelineIdentifier", obj_pipelineIdentifier_arr[i], const_cast((o.pipelineIdentifier[i]))); + } + + parse_VkPipelineMatchControl("matchControl", obj["matchControl"], (o.matchControl)); + + parse_VkDeviceSize("poolEntrySize", obj["poolEntrySize"], (o.poolEntrySize)); + +} +#endif + +#ifdef VKSC_VERSION_1_0 +static void parse_VkPipelineCacheStageValidationIndexEntry(const char* s, Json::Value& obj, VkPipelineCacheStageValidationIndexEntry& o) { + + parse_uint64_t("codeSize", obj["codeSize"], (o.codeSize)); + + parse_uint64_t("codeOffset", obj["codeOffset"], (o.codeOffset)); + +} +#endif + +#ifdef VKSC_VERSION_1_0 +static void parse_VkPipelineCacheSafetyCriticalIndexEntry(const char* s, Json::Value& obj, VkPipelineCacheSafetyCriticalIndexEntry& o) { + + Json::Value& obj_pipelineIdentifier_arr = obj["pipelineIdentifier"]; + for (unsigned int i = 0; i < obj_pipelineIdentifier_arr.size(); i++) { + parse_uint8_t("pipelineIdentifier", obj_pipelineIdentifier_arr[i], const_cast((o.pipelineIdentifier[i]))); + } + + parse_uint64_t("pipelineMemorySize", obj["pipelineMemorySize"], (o.pipelineMemorySize)); + + parse_uint64_t("jsonSize", obj["jsonSize"], (o.jsonSize)); + + parse_uint64_t("jsonOffset", obj["jsonOffset"], (o.jsonOffset)); + + parse_uint32_t("stageIndexCount", obj["stageIndexCount"], (o.stageIndexCount)); + + parse_uint32_t("stageIndexStride", obj["stageIndexStride"], (o.stageIndexStride)); + + parse_uint64_t("stageIndexOffset", obj["stageIndexOffset"], (o.stageIndexOffset)); + +} +#endif + +#ifdef VKSC_VERSION_1_0 +static void parse_VkPipelineCacheHeaderVersionSafetyCriticalOne(const char* s, Json::Value& obj, VkPipelineCacheHeaderVersionSafetyCriticalOne& o) { + + parse_VkPipelineCacheHeaderVersionOne("headerVersionOne", obj["headerVersionOne"], (o.headerVersionOne)); + + parse_VkPipelineCacheValidationVersion("validationVersion", obj["validationVersion"], (o.validationVersion)); + + parse_uint32_t("implementationData", obj["implementationData"], (o.implementationData)); + + parse_uint32_t("pipelineIndexCount", obj["pipelineIndexCount"], (o.pipelineIndexCount)); + + parse_uint32_t("pipelineIndexStride", obj["pipelineIndexStride"], (o.pipelineIndexStride)); + + parse_uint64_t("pipelineIndexOffset", obj["pipelineIndexOffset"], (o.pipelineIndexOffset)); + +} +#endif + +#ifdef VK_KHR_surface +static void parse_VkSurfaceKHR(const char* s, Json::Value& obj, VkSurfaceKHR& o) { +// std::string _res = obj.asString(); +} +#endif + +#ifdef VK_KHR_surface +static std::map VkSurfaceTransformFlagBitsKHR_map = { + std::make_pair("VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR", 1UL << 0), + std::make_pair("VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR", 1UL << 1), + std::make_pair("VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR", 1UL << 2), + std::make_pair("VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR", 1UL << 3), + std::make_pair("VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR", 1UL << 4), + std::make_pair("VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR", 1UL << 5), + std::make_pair("VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR", 1UL << 6), + std::make_pair("VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR", 1UL << 7), + std::make_pair("VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR", 1UL << 8), +}; +static void parse_VkSurfaceTransformFlagBitsKHR(const char* s, Json::Value& obj, VkSurfaceTransformFlagBitsKHR& o) { + std::string _res = obj.asString(); + o = (VkSurfaceTransformFlagBitsKHR)VkSurfaceTransformFlagBitsKHR_map[std::string(_res)]; +} +#endif + +#ifdef VK_KHR_surface +static std::map VkPresentModeKHR_map = { + std::make_pair("VK_PRESENT_MODE_IMMEDIATE_KHR", 0), + std::make_pair("VK_PRESENT_MODE_MAILBOX_KHR", 1), + std::make_pair("VK_PRESENT_MODE_FIFO_KHR", 2), + std::make_pair("VK_PRESENT_MODE_FIFO_RELAXED_KHR", 3), + std::make_pair("VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR", 1000111000), + std::make_pair("VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR", 1000111001), +}; +static void parse_VkPresentModeKHR(const char* s, Json::Value& obj, VkPresentModeKHR& o) { + std::string _res = obj.asString(); + o = (VkPresentModeKHR)VkPresentModeKHR_map[std::string(_res)]; +} +#endif + +#ifdef VK_KHR_surface +static std::map VkColorSpaceKHR_map = { + std::make_pair("VK_COLOR_SPACE_SRGB_NONLINEAR_KHR", 0), + std::make_pair("VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT", 1000104001), + std::make_pair("VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT", 1000104002), + std::make_pair("VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT", 1000104003), + std::make_pair("VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT", 1000104004), + std::make_pair("VK_COLOR_SPACE_BT709_LINEAR_EXT", 1000104005), + std::make_pair("VK_COLOR_SPACE_BT709_NONLINEAR_EXT", 1000104006), + std::make_pair("VK_COLOR_SPACE_BT2020_LINEAR_EXT", 1000104007), + std::make_pair("VK_COLOR_SPACE_HDR10_ST2084_EXT", 1000104008), + std::make_pair("VK_COLOR_SPACE_DOLBYVISION_EXT", 1000104009), + std::make_pair("VK_COLOR_SPACE_HDR10_HLG_EXT", 1000104010), + std::make_pair("VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT", 1000104011), + std::make_pair("VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT", 1000104012), + std::make_pair("VK_COLOR_SPACE_PASS_THROUGH_EXT", 1000104013), + std::make_pair("VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT", 1000104014), + std::make_pair("VK_COLOR_SPACE_DISPLAY_NATIVE_AMD", 1000213000), +}; +static void parse_VkColorSpaceKHR(const char* s, Json::Value& obj, VkColorSpaceKHR& o) { + std::string _res = obj.asString(); + o = (VkColorSpaceKHR)VkColorSpaceKHR_map[std::string(_res)]; +} +#endif + +#ifdef VK_KHR_surface +static std::map VkCompositeAlphaFlagBitsKHR_map = { + std::make_pair("VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR", 1UL << 0), + std::make_pair("VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR", 1UL << 1), + std::make_pair("VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR", 1UL << 2), + std::make_pair("VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR", 1UL << 3), +}; +static void parse_VkCompositeAlphaFlagBitsKHR(const char* s, Json::Value& obj, VkCompositeAlphaFlagBitsKHR& o) { + std::string _res = obj.asString(); + o = (VkCompositeAlphaFlagBitsKHR)VkCompositeAlphaFlagBitsKHR_map[std::string(_res)]; +} +#endif + +#ifdef VK_KHR_surface +static void parse_VkCompositeAlphaFlagsKHR(const char* s, Json::Value& obj, VkCompositeAlphaFlagsKHR& o) { + o = (VkCompositeAlphaFlagsKHR)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkCompositeAlphaFlagBitsKHR)VkCompositeAlphaFlagBitsKHR_map[it]; + } +} +#endif + +#ifdef VK_KHR_surface +static void parse_VkSurfaceTransformFlagsKHR(const char* s, Json::Value& obj, VkSurfaceTransformFlagsKHR& o) { + o = (VkSurfaceTransformFlagsKHR)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkSurfaceTransformFlagBitsKHR)VkSurfaceTransformFlagBitsKHR_map[it]; + } +} +#endif + +#ifdef VK_KHR_surface +static void parse_VkSurfaceCapabilitiesKHR(const char* s, Json::Value& obj, VkSurfaceCapabilitiesKHR& o) { + + parse_uint32_t("minImageCount", obj["minImageCount"], (o.minImageCount)); + + parse_uint32_t("maxImageCount", obj["maxImageCount"], (o.maxImageCount)); + + parse_VkExtent2D("currentExtent", obj["currentExtent"], (o.currentExtent)); + + parse_VkExtent2D("minImageExtent", obj["minImageExtent"], (o.minImageExtent)); + + parse_VkExtent2D("maxImageExtent", obj["maxImageExtent"], (o.maxImageExtent)); + + parse_uint32_t("maxImageArrayLayers", obj["maxImageArrayLayers"], (o.maxImageArrayLayers)); + + parse_VkSurfaceTransformFlagsKHR("supportedTransforms", obj["supportedTransforms"], (o.supportedTransforms)); + + parse_VkSurfaceTransformFlagBitsKHR("currentTransform", obj["currentTransform"], (o.currentTransform)); + + parse_VkCompositeAlphaFlagsKHR("supportedCompositeAlpha", obj["supportedCompositeAlpha"], (o.supportedCompositeAlpha)); + + parse_VkImageUsageFlags("supportedUsageFlags", obj["supportedUsageFlags"], (o.supportedUsageFlags)); + +} +#endif + +#ifdef VK_KHR_surface +static void parse_VkSurfaceFormatKHR(const char* s, Json::Value& obj, VkSurfaceFormatKHR& o) { + + parse_VkFormat("format", obj["format"], (o.format)); + + parse_VkColorSpaceKHR("colorSpace", obj["colorSpace"], (o.colorSpace)); + +} +#endif + +#ifdef VK_KHR_swapchain +static void parse_VkSwapchainKHR(const char* s, Json::Value& obj, VkSwapchainKHR& o) { +// std::string _res = obj.asString(); +} +#endif + +#ifdef VK_KHR_swapchain +static std::map VkSwapchainCreateFlagBitsKHR_map = { + std::make_pair("VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR", 1UL << 0), + std::make_pair("VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR", 1UL << 1), + std::make_pair("VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR", 1UL << 0), + std::make_pair("VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR", 1UL << 2), +}; +static void parse_VkSwapchainCreateFlagBitsKHR(const char* s, Json::Value& obj, VkSwapchainCreateFlagBitsKHR& o) { + std::string _res = obj.asString(); + o = (VkSwapchainCreateFlagBitsKHR)VkSwapchainCreateFlagBitsKHR_map[std::string(_res)]; +} +#endif + +#ifdef VK_KHR_swapchain +static std::map VkDeviceGroupPresentModeFlagBitsKHR_map = { + std::make_pair("VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR", 1UL << 0), + std::make_pair("VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR", 1UL << 1), + std::make_pair("VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR", 1UL << 2), + std::make_pair("VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR", 1UL << 3), +}; +static void parse_VkDeviceGroupPresentModeFlagBitsKHR(const char* s, Json::Value& obj, VkDeviceGroupPresentModeFlagBitsKHR& o) { + std::string _res = obj.asString(); + o = (VkDeviceGroupPresentModeFlagBitsKHR)VkDeviceGroupPresentModeFlagBitsKHR_map[std::string(_res)]; +} +#endif + +#ifdef VK_KHR_swapchain +static void parse_VkSwapchainCreateFlagsKHR(const char* s, Json::Value& obj, VkSwapchainCreateFlagsKHR& o) { + o = (VkSwapchainCreateFlagsKHR)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkSwapchainCreateFlagBitsKHR)VkSwapchainCreateFlagBitsKHR_map[it]; + } +} +#endif + +#ifdef VK_KHR_swapchain +static void parse_VkDeviceGroupPresentModeFlagsKHR(const char* s, Json::Value& obj, VkDeviceGroupPresentModeFlagsKHR& o) { + o = (VkDeviceGroupPresentModeFlagsKHR)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkDeviceGroupPresentModeFlagBitsKHR)VkDeviceGroupPresentModeFlagBitsKHR_map[it]; + } +} +#endif + +#ifdef VK_KHR_swapchain +static void parse_VkSwapchainCreateInfoKHR(const char* s, Json::Value& obj, VkSwapchainCreateInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSwapchainCreateInfoKHR*)parsePNextChain(obj); + + parse_VkSwapchainCreateFlagsKHR("flags", obj["flags"], (o.flags)); + + + parse_uint32_t("minImageCount", obj["minImageCount"], (o.minImageCount)); + + parse_VkFormat("imageFormat", obj["imageFormat"], (o.imageFormat)); + + parse_VkColorSpaceKHR("imageColorSpace", obj["imageColorSpace"], (o.imageColorSpace)); + + parse_VkExtent2D("imageExtent", obj["imageExtent"], (o.imageExtent)); + + parse_uint32_t("imageArrayLayers", obj["imageArrayLayers"], (o.imageArrayLayers)); + + parse_VkImageUsageFlags("imageUsage", obj["imageUsage"], (o.imageUsage)); + + parse_VkSharingMode("imageSharingMode", obj["imageSharingMode"], (o.imageSharingMode)); + + parse_uint32_t("queueFamilyIndexCount", obj["queueFamilyIndexCount"], (o.queueFamilyIndexCount)); + + (o.pQueueFamilyIndices) = (uint32_t*)s_globalMem.allocate((o.queueFamilyIndexCount), sizeof(uint32_t)); + Json::Value& obj_pQueueFamilyIndices_arr = obj["pQueueFamilyIndices"]; + for (unsigned int i = 0; i < obj_pQueueFamilyIndices_arr.size(); i++) { + parse_uint32_t("pQueueFamilyIndices", obj_pQueueFamilyIndices_arr[i], const_cast((o.pQueueFamilyIndices[i]))); + } + + parse_VkSurfaceTransformFlagBitsKHR("preTransform", obj["preTransform"], (o.preTransform)); + + parse_VkCompositeAlphaFlagBitsKHR("compositeAlpha", obj["compositeAlpha"], (o.compositeAlpha)); + + parse_VkPresentModeKHR("presentMode", obj["presentMode"], (o.presentMode)); + + parse_VkBool32("clipped", obj["clipped"], (o.clipped)); + + +} +#endif + +#ifdef VK_KHR_swapchain +static void parse_VkPresentInfoKHR(const char* s, Json::Value& obj, VkPresentInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPresentInfoKHR*)parsePNextChain(obj); + + parse_uint32_t("waitSemaphoreCount", obj["waitSemaphoreCount"], (o.waitSemaphoreCount)); + + (o.pWaitSemaphores) = (VkSemaphore*)s_globalMem.allocate((o.waitSemaphoreCount), sizeof(VkSemaphore)); + Json::Value& obj_pWaitSemaphores_arr = obj["pWaitSemaphores"]; + for (unsigned int i = 0; i < obj_pWaitSemaphores_arr.size(); i++) { + parse_VkSemaphore("pWaitSemaphores", obj_pWaitSemaphores_arr[i], const_cast((o.pWaitSemaphores[i]))); + } + + parse_uint32_t("swapchainCount", obj["swapchainCount"], (o.swapchainCount)); + + (o.pSwapchains) = (VkSwapchainKHR*)s_globalMem.allocate((o.swapchainCount), sizeof(VkSwapchainKHR)); + Json::Value& obj_pSwapchains_arr = obj["pSwapchains"]; + for (unsigned int i = 0; i < obj_pSwapchains_arr.size(); i++) { + parse_VkSwapchainKHR("pSwapchains", obj_pSwapchains_arr[i], const_cast((o.pSwapchains[i]))); + } + + (o.pImageIndices) = (uint32_t*)s_globalMem.allocate((o.swapchainCount), sizeof(uint32_t)); + Json::Value& obj_pImageIndices_arr = obj["pImageIndices"]; + for (unsigned int i = 0; i < obj_pImageIndices_arr.size(); i++) { + parse_uint32_t("pImageIndices", obj_pImageIndices_arr[i], const_cast((o.pImageIndices[i]))); + } + + +} +#endif + +#ifdef VK_KHR_swapchain +static void parse_VkImageSwapchainCreateInfoKHR(const char* s, Json::Value& obj, VkImageSwapchainCreateInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImageSwapchainCreateInfoKHR*)parsePNextChain(obj); + + +} +#endif + +#ifdef VK_KHR_swapchain +static void parse_VkBindImageMemorySwapchainInfoKHR(const char* s, Json::Value& obj, VkBindImageMemorySwapchainInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkBindImageMemorySwapchainInfoKHR*)parsePNextChain(obj); + + + parse_uint32_t("imageIndex", obj["imageIndex"], (o.imageIndex)); + +} +#endif + +#ifdef VK_KHR_swapchain +static void parse_VkAcquireNextImageInfoKHR(const char* s, Json::Value& obj, VkAcquireNextImageInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkAcquireNextImageInfoKHR*)parsePNextChain(obj); + + + parse_uint64_t("timeout", obj["timeout"], (o.timeout)); + + + + parse_uint32_t("deviceMask", obj["deviceMask"], (o.deviceMask)); + +} +#endif + +#ifdef VK_KHR_swapchain +static void parse_VkDeviceGroupPresentCapabilitiesKHR(const char* s, Json::Value& obj, VkDeviceGroupPresentCapabilitiesKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDeviceGroupPresentCapabilitiesKHR*)parsePNextChain(obj); + + Json::Value& obj_presentMask_arr = obj["presentMask"]; + for (unsigned int i = 0; i < obj_presentMask_arr.size(); i++) { + parse_uint32_t("presentMask", obj_presentMask_arr[i], const_cast((o.presentMask[i]))); + } + + parse_VkDeviceGroupPresentModeFlagsKHR("modes", obj["modes"], (o.modes)); + +} +#endif + +#ifdef VK_KHR_swapchain +static void parse_VkDeviceGroupPresentInfoKHR(const char* s, Json::Value& obj, VkDeviceGroupPresentInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDeviceGroupPresentInfoKHR*)parsePNextChain(obj); + + parse_uint32_t("swapchainCount", obj["swapchainCount"], (o.swapchainCount)); + + (o.pDeviceMasks) = (uint32_t*)s_globalMem.allocate((o.swapchainCount), sizeof(uint32_t)); + Json::Value& obj_pDeviceMasks_arr = obj["pDeviceMasks"]; + for (unsigned int i = 0; i < obj_pDeviceMasks_arr.size(); i++) { + parse_uint32_t("pDeviceMasks", obj_pDeviceMasks_arr[i], const_cast((o.pDeviceMasks[i]))); + } + + parse_VkDeviceGroupPresentModeFlagBitsKHR("mode", obj["mode"], (o.mode)); + +} +#endif + +#ifdef VK_KHR_swapchain +static void parse_VkDeviceGroupSwapchainCreateInfoKHR(const char* s, Json::Value& obj, VkDeviceGroupSwapchainCreateInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDeviceGroupSwapchainCreateInfoKHR*)parsePNextChain(obj); + + parse_VkDeviceGroupPresentModeFlagsKHR("modes", obj["modes"], (o.modes)); + +} +#endif + +#ifdef VK_KHR_display +static void parse_VkDisplayKHR(const char* s, Json::Value& obj, VkDisplayKHR& o) { +// std::string _res = obj.asString(); +} +#endif + +#ifdef VK_KHR_display +static void parse_VkDisplayModeKHR(const char* s, Json::Value& obj, VkDisplayModeKHR& o) { +// std::string _res = obj.asString(); +} +#endif + +#ifdef VK_KHR_display +static std::map VkDisplayPlaneAlphaFlagBitsKHR_map = { + std::make_pair("VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR", 1UL << 0), + std::make_pair("VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR", 1UL << 1), + std::make_pair("VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR", 1UL << 2), + std::make_pair("VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR", 1UL << 3), +}; +static void parse_VkDisplayPlaneAlphaFlagBitsKHR(const char* s, Json::Value& obj, VkDisplayPlaneAlphaFlagBitsKHR& o) { + std::string _res = obj.asString(); + o = (VkDisplayPlaneAlphaFlagBitsKHR)VkDisplayPlaneAlphaFlagBitsKHR_map[std::string(_res)]; +} +#endif + +#ifdef VK_KHR_display +static void parse_VkDisplayModeCreateFlagsKHR(const char* s, Json::Value& obj, VkDisplayModeCreateFlagsKHR& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} +#endif + +#ifdef VK_KHR_display +static void parse_VkDisplayPlaneAlphaFlagsKHR(const char* s, Json::Value& obj, VkDisplayPlaneAlphaFlagsKHR& o) { + o = (VkDisplayPlaneAlphaFlagsKHR)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkDisplayPlaneAlphaFlagBitsKHR)VkDisplayPlaneAlphaFlagBitsKHR_map[it]; + } +} +#endif + +#ifdef VK_KHR_display +static void parse_VkDisplaySurfaceCreateFlagsKHR(const char* s, Json::Value& obj, VkDisplaySurfaceCreateFlagsKHR& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} +#endif + +#ifdef VK_KHR_display +static void parse_VkDisplayModeParametersKHR(const char* s, Json::Value& obj, VkDisplayModeParametersKHR& o) { + + parse_VkExtent2D("visibleRegion", obj["visibleRegion"], (o.visibleRegion)); + + parse_uint32_t("refreshRate", obj["refreshRate"], (o.refreshRate)); + +} +#endif + +#ifdef VK_KHR_display +static void parse_VkDisplayModeCreateInfoKHR(const char* s, Json::Value& obj, VkDisplayModeCreateInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDisplayModeCreateInfoKHR*)parsePNextChain(obj); + + parse_VkDisplayModeCreateFlagsKHR("flags", obj["flags"], (o.flags)); + + parse_VkDisplayModeParametersKHR("parameters", obj["parameters"], (o.parameters)); + +} +#endif + +#ifdef VK_KHR_display +static void parse_VkDisplayModePropertiesKHR(const char* s, Json::Value& obj, VkDisplayModePropertiesKHR& o) { + + + parse_VkDisplayModeParametersKHR("parameters", obj["parameters"], (o.parameters)); + +} +#endif + +#ifdef VK_KHR_display +static void parse_VkDisplayPlaneCapabilitiesKHR(const char* s, Json::Value& obj, VkDisplayPlaneCapabilitiesKHR& o) { + + parse_VkDisplayPlaneAlphaFlagsKHR("supportedAlpha", obj["supportedAlpha"], (o.supportedAlpha)); + + parse_VkOffset2D("minSrcPosition", obj["minSrcPosition"], (o.minSrcPosition)); + + parse_VkOffset2D("maxSrcPosition", obj["maxSrcPosition"], (o.maxSrcPosition)); + + parse_VkExtent2D("minSrcExtent", obj["minSrcExtent"], (o.minSrcExtent)); + + parse_VkExtent2D("maxSrcExtent", obj["maxSrcExtent"], (o.maxSrcExtent)); + + parse_VkOffset2D("minDstPosition", obj["minDstPosition"], (o.minDstPosition)); + + parse_VkOffset2D("maxDstPosition", obj["maxDstPosition"], (o.maxDstPosition)); + + parse_VkExtent2D("minDstExtent", obj["minDstExtent"], (o.minDstExtent)); + + parse_VkExtent2D("maxDstExtent", obj["maxDstExtent"], (o.maxDstExtent)); + +} +#endif + +#ifdef VK_KHR_display +static void parse_VkDisplayPlanePropertiesKHR(const char* s, Json::Value& obj, VkDisplayPlanePropertiesKHR& o) { + + + parse_uint32_t("currentStackIndex", obj["currentStackIndex"], (o.currentStackIndex)); + +} +#endif + +#ifdef VK_KHR_display +static void parse_VkDisplayPropertiesKHR(const char* s, Json::Value& obj, VkDisplayPropertiesKHR& o) { + + + /** TODO: Handle this - displayName **/ + + parse_VkExtent2D("physicalDimensions", obj["physicalDimensions"], (o.physicalDimensions)); + + parse_VkExtent2D("physicalResolution", obj["physicalResolution"], (o.physicalResolution)); + + parse_VkSurfaceTransformFlagsKHR("supportedTransforms", obj["supportedTransforms"], (o.supportedTransforms)); + + parse_VkBool32("planeReorderPossible", obj["planeReorderPossible"], (o.planeReorderPossible)); + + parse_VkBool32("persistentContent", obj["persistentContent"], (o.persistentContent)); + +} +#endif + +#ifdef VK_KHR_display +static void parse_VkDisplaySurfaceCreateInfoKHR(const char* s, Json::Value& obj, VkDisplaySurfaceCreateInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDisplaySurfaceCreateInfoKHR*)parsePNextChain(obj); + + parse_VkDisplaySurfaceCreateFlagsKHR("flags", obj["flags"], (o.flags)); + + + parse_uint32_t("planeIndex", obj["planeIndex"], (o.planeIndex)); + + parse_uint32_t("planeStackIndex", obj["planeStackIndex"], (o.planeStackIndex)); + + parse_VkSurfaceTransformFlagBitsKHR("transform", obj["transform"], (o.transform)); + + parse_float("globalAlpha", obj["globalAlpha"], (o.globalAlpha)); + + parse_VkDisplayPlaneAlphaFlagBitsKHR("alphaMode", obj["alphaMode"], (o.alphaMode)); + + parse_VkExtent2D("imageExtent", obj["imageExtent"], (o.imageExtent)); + +} +#endif + +#ifdef VK_KHR_display_swapchain +static void parse_VkDisplayPresentInfoKHR(const char* s, Json::Value& obj, VkDisplayPresentInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDisplayPresentInfoKHR*)parsePNextChain(obj); + + parse_VkRect2D("srcRect", obj["srcRect"], (o.srcRect)); + + parse_VkRect2D("dstRect", obj["dstRect"], (o.dstRect)); + + parse_VkBool32("persistent", obj["persistent"], (o.persistent)); + +} +#endif + +#ifdef VK_KHR_external_memory_fd +static void parse_VkImportMemoryFdInfoKHR(const char* s, Json::Value& obj, VkImportMemoryFdInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImportMemoryFdInfoKHR*)parsePNextChain(obj); + + parse_VkExternalMemoryHandleTypeFlagBits("handleType", obj["handleType"], (o.handleType)); + + parse_int("fd", obj["fd"], (o.fd)); + +} +#endif + +#ifdef VK_KHR_external_memory_fd +static void parse_VkMemoryFdPropertiesKHR(const char* s, Json::Value& obj, VkMemoryFdPropertiesKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkMemoryFdPropertiesKHR*)parsePNextChain(obj); + + parse_uint32_t("memoryTypeBits", obj["memoryTypeBits"], (o.memoryTypeBits)); + +} +#endif + +#ifdef VK_KHR_external_memory_fd +static void parse_VkMemoryGetFdInfoKHR(const char* s, Json::Value& obj, VkMemoryGetFdInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkMemoryGetFdInfoKHR*)parsePNextChain(obj); + + + parse_VkExternalMemoryHandleTypeFlagBits("handleType", obj["handleType"], (o.handleType)); + +} +#endif + +#ifdef VK_KHR_external_semaphore_fd +static void parse_VkImportSemaphoreFdInfoKHR(const char* s, Json::Value& obj, VkImportSemaphoreFdInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImportSemaphoreFdInfoKHR*)parsePNextChain(obj); + + + parse_VkSemaphoreImportFlags("flags", obj["flags"], (o.flags)); + + parse_VkExternalSemaphoreHandleTypeFlagBits("handleType", obj["handleType"], (o.handleType)); + + parse_int("fd", obj["fd"], (o.fd)); + +} +#endif + +#ifdef VK_KHR_external_semaphore_fd +static void parse_VkSemaphoreGetFdInfoKHR(const char* s, Json::Value& obj, VkSemaphoreGetFdInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSemaphoreGetFdInfoKHR*)parsePNextChain(obj); + + + parse_VkExternalSemaphoreHandleTypeFlagBits("handleType", obj["handleType"], (o.handleType)); + +} +#endif + +#ifdef VK_KHR_incremental_present +static void parse_VkRectLayerKHR(const char* s, Json::Value& obj, VkRectLayerKHR& o) { + + parse_VkOffset2D("offset", obj["offset"], (o.offset)); + + parse_VkExtent2D("extent", obj["extent"], (o.extent)); + + parse_uint32_t("layer", obj["layer"], (o.layer)); + +} +#endif + +#ifdef VK_KHR_incremental_present +static void parse_VkPresentRegionKHR(const char* s, Json::Value& obj, VkPresentRegionKHR& o) { + + parse_uint32_t("rectangleCount", obj["rectangleCount"], (o.rectangleCount)); + + (o.pRectangles) = (VkRectLayerKHR*)s_globalMem.allocate((o.rectangleCount), sizeof(VkRectLayerKHR)); + Json::Value& obj_pRectangles = obj["pRectangles"]; + if (obj_pRectangles.size() == 0) (o.pRectangles) = nullptr; + else { + for (unsigned int i = 0; i < (o.rectangleCount); i++) { + parse_VkRectLayerKHR("pRectangles", obj_pRectangles[i], const_cast((o.pRectangles[i]))); + } + } + +} +#endif + +#ifdef VK_KHR_incremental_present +static void parse_VkPresentRegionsKHR(const char* s, Json::Value& obj, VkPresentRegionsKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPresentRegionsKHR*)parsePNextChain(obj); + + parse_uint32_t("swapchainCount", obj["swapchainCount"], (o.swapchainCount)); + + (o.pRegions) = (VkPresentRegionKHR*)s_globalMem.allocate((o.swapchainCount), sizeof(VkPresentRegionKHR)); + Json::Value& obj_pRegions = obj["pRegions"]; + if (obj_pRegions.size() == 0) (o.pRegions) = nullptr; + else { + for (unsigned int i = 0; i < (o.swapchainCount); i++) { + parse_VkPresentRegionKHR("pRegions", obj_pRegions[i], const_cast((o.pRegions[i]))); + } + } + +} +#endif + +#ifdef VK_KHR_shared_presentable_image +static void parse_VkSharedPresentSurfaceCapabilitiesKHR(const char* s, Json::Value& obj, VkSharedPresentSurfaceCapabilitiesKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSharedPresentSurfaceCapabilitiesKHR*)parsePNextChain(obj); + + parse_VkImageUsageFlags("sharedPresentSupportedUsageFlags", obj["sharedPresentSupportedUsageFlags"], (o.sharedPresentSupportedUsageFlags)); + +} +#endif + +#ifdef VK_KHR_external_fence_fd +static void parse_VkImportFenceFdInfoKHR(const char* s, Json::Value& obj, VkImportFenceFdInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImportFenceFdInfoKHR*)parsePNextChain(obj); + + + parse_VkFenceImportFlags("flags", obj["flags"], (o.flags)); + + parse_VkExternalFenceHandleTypeFlagBits("handleType", obj["handleType"], (o.handleType)); + + parse_int("fd", obj["fd"], (o.fd)); + +} +#endif + +#ifdef VK_KHR_external_fence_fd +static void parse_VkFenceGetFdInfoKHR(const char* s, Json::Value& obj, VkFenceGetFdInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkFenceGetFdInfoKHR*)parsePNextChain(obj); + + + parse_VkExternalFenceHandleTypeFlagBits("handleType", obj["handleType"], (o.handleType)); + +} +#endif + +#ifdef VK_KHR_performance_query +static std::map VkPerformanceCounterUnitKHR_map = { + std::make_pair("VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR", 0), + std::make_pair("VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR", 1), + std::make_pair("VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR", 2), + std::make_pair("VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR", 3), + std::make_pair("VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR", 4), + std::make_pair("VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR", 5), + std::make_pair("VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR", 6), + std::make_pair("VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR", 7), + std::make_pair("VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR", 8), + std::make_pair("VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR", 9), + std::make_pair("VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR", 10), +}; +static void parse_VkPerformanceCounterUnitKHR(const char* s, Json::Value& obj, VkPerformanceCounterUnitKHR& o) { + std::string _res = obj.asString(); + o = (VkPerformanceCounterUnitKHR)VkPerformanceCounterUnitKHR_map[std::string(_res)]; +} +#endif + +#ifdef VK_KHR_performance_query +static std::map VkPerformanceCounterScopeKHR_map = { + std::make_pair("VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR", 0), + std::make_pair("VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR", 1), + std::make_pair("VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR", 2), +}; +static void parse_VkPerformanceCounterScopeKHR(const char* s, Json::Value& obj, VkPerformanceCounterScopeKHR& o) { + std::string _res = obj.asString(); + o = (VkPerformanceCounterScopeKHR)VkPerformanceCounterScopeKHR_map[std::string(_res)]; +} +#endif + +#ifdef VK_KHR_performance_query +static std::map VkPerformanceCounterStorageKHR_map = { + std::make_pair("VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR", 0), + std::make_pair("VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR", 1), + std::make_pair("VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR", 2), + std::make_pair("VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR", 3), + std::make_pair("VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR", 4), + std::make_pair("VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR", 5), +}; +static void parse_VkPerformanceCounterStorageKHR(const char* s, Json::Value& obj, VkPerformanceCounterStorageKHR& o) { + std::string _res = obj.asString(); + o = (VkPerformanceCounterStorageKHR)VkPerformanceCounterStorageKHR_map[std::string(_res)]; +} +#endif + +#ifdef VK_KHR_performance_query +static std::map VkPerformanceCounterDescriptionFlagBitsKHR_map = { + std::make_pair("VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR", 1UL << 0), + std::make_pair("VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR", 1UL << 1), +}; +static void parse_VkPerformanceCounterDescriptionFlagBitsKHR(const char* s, Json::Value& obj, VkPerformanceCounterDescriptionFlagBitsKHR& o) { + std::string _res = obj.asString(); + o = (VkPerformanceCounterDescriptionFlagBitsKHR)VkPerformanceCounterDescriptionFlagBitsKHR_map[std::string(_res)]; +} +#endif + +#ifdef VK_KHR_performance_query +static std::map VkAcquireProfilingLockFlagBitsKHR_map = { +}; +static void parse_VkAcquireProfilingLockFlagBitsKHR(const char* s, Json::Value& obj, VkAcquireProfilingLockFlagBitsKHR& o) { + std::string _res = obj.asString(); + o = (VkAcquireProfilingLockFlagBitsKHR)VkAcquireProfilingLockFlagBitsKHR_map[std::string(_res)]; +} +#endif + +#ifdef VK_KHR_performance_query +static void parse_VkPerformanceCounterDescriptionFlagsKHR(const char* s, Json::Value& obj, VkPerformanceCounterDescriptionFlagsKHR& o) { + o = (VkPerformanceCounterDescriptionFlagsKHR)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkPerformanceCounterDescriptionFlagBitsKHR)VkPerformanceCounterDescriptionFlagBitsKHR_map[it]; + } +} +#endif + +#ifdef VK_KHR_performance_query +static void parse_VkAcquireProfilingLockFlagsKHR(const char* s, Json::Value& obj, VkAcquireProfilingLockFlagsKHR& o) { + o = (VkAcquireProfilingLockFlagsKHR)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkAcquireProfilingLockFlagBitsKHR)VkAcquireProfilingLockFlagBitsKHR_map[it]; + } +} +#endif + +#ifdef VK_KHR_performance_query +static void parse_VkPhysicalDevicePerformanceQueryFeaturesKHR(const char* s, Json::Value& obj, VkPhysicalDevicePerformanceQueryFeaturesKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDevicePerformanceQueryFeaturesKHR*)parsePNextChain(obj); + + parse_VkBool32("performanceCounterQueryPools", obj["performanceCounterQueryPools"], (o.performanceCounterQueryPools)); + + parse_VkBool32("performanceCounterMultipleQueryPools", obj["performanceCounterMultipleQueryPools"], (o.performanceCounterMultipleQueryPools)); + +} +#endif + +#ifdef VK_KHR_performance_query +static void parse_VkPhysicalDevicePerformanceQueryPropertiesKHR(const char* s, Json::Value& obj, VkPhysicalDevicePerformanceQueryPropertiesKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDevicePerformanceQueryPropertiesKHR*)parsePNextChain(obj); + + parse_VkBool32("allowCommandBufferQueryCopies", obj["allowCommandBufferQueryCopies"], (o.allowCommandBufferQueryCopies)); + +} +#endif + +#ifdef VK_KHR_performance_query +static void parse_VkPerformanceCounterKHR(const char* s, Json::Value& obj, VkPerformanceCounterKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPerformanceCounterKHR*)parsePNextChain(obj); + + parse_VkPerformanceCounterUnitKHR("unit", obj["unit"], (o.unit)); + + parse_VkPerformanceCounterScopeKHR("scope", obj["scope"], (o.scope)); + + parse_VkPerformanceCounterStorageKHR("storage", obj["storage"], (o.storage)); + + Json::Value& obj_uuid_arr = obj["uuid"]; + for (unsigned int i = 0; i < obj_uuid_arr.size(); i++) { + parse_uint8_t("uuid", obj_uuid_arr[i], const_cast((o.uuid[i]))); + } + +} +#endif + +#ifdef VK_KHR_performance_query +static void parse_VkPerformanceCounterDescriptionKHR(const char* s, Json::Value& obj, VkPerformanceCounterDescriptionKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPerformanceCounterDescriptionKHR*)parsePNextChain(obj); + + parse_VkPerformanceCounterDescriptionFlagsKHR("flags", obj["flags"], (o.flags)); + + /** TODO: Handle this - name **/ + + /** TODO: Handle this - category **/ + + /** TODO: Handle this - description **/ + +} +#endif + +#ifdef VK_KHR_performance_query +static void parse_VkQueryPoolPerformanceCreateInfoKHR(const char* s, Json::Value& obj, VkQueryPoolPerformanceCreateInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkQueryPoolPerformanceCreateInfoKHR*)parsePNextChain(obj); + + parse_uint32_t("queueFamilyIndex", obj["queueFamilyIndex"], (o.queueFamilyIndex)); + + parse_uint32_t("counterIndexCount", obj["counterIndexCount"], (o.counterIndexCount)); + + (o.pCounterIndices) = (uint32_t*)s_globalMem.allocate((o.counterIndexCount), sizeof(uint32_t)); + Json::Value& obj_pCounterIndices_arr = obj["pCounterIndices"]; + for (unsigned int i = 0; i < obj_pCounterIndices_arr.size(); i++) { + parse_uint32_t("pCounterIndices", obj_pCounterIndices_arr[i], const_cast((o.pCounterIndices[i]))); + } + +} +#endif + +#ifdef VK_KHR_performance_query +static void parse_VkPerformanceCounterResultKHR(const char* s, Json::Value& obj, VkPerformanceCounterResultKHR& o) { + + parse_int32_t("int32", obj["int32"], (o.int32)); + + parse_int64_t("int64", obj["int64"], (o.int64)); + + parse_uint32_t("uint32", obj["uint32"], (o.uint32)); + + parse_uint64_t("uint64", obj["uint64"], (o.uint64)); + + parse_float("float32", obj["float32"], (o.float32)); + + parse_double("float64", obj["float64"], (o.float64)); + +} +#endif + +#ifdef VK_KHR_performance_query +static void parse_VkAcquireProfilingLockInfoKHR(const char* s, Json::Value& obj, VkAcquireProfilingLockInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkAcquireProfilingLockInfoKHR*)parsePNextChain(obj); + + parse_VkAcquireProfilingLockFlagsKHR("flags", obj["flags"], (o.flags)); + + parse_uint64_t("timeout", obj["timeout"], (o.timeout)); + +} +#endif + +#ifdef VK_KHR_performance_query +static void parse_VkPerformanceQuerySubmitInfoKHR(const char* s, Json::Value& obj, VkPerformanceQuerySubmitInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPerformanceQuerySubmitInfoKHR*)parsePNextChain(obj); + + parse_uint32_t("counterPassIndex", obj["counterPassIndex"], (o.counterPassIndex)); + +} +#endif + +#ifdef VK_KHR_performance_query +static void parse_VkPerformanceQueryReservationInfoKHR(const char* s, Json::Value& obj, VkPerformanceQueryReservationInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPerformanceQueryReservationInfoKHR*)parsePNextChain(obj); + + parse_uint32_t("maxPerformanceQueriesPerPool", obj["maxPerformanceQueriesPerPool"], (o.maxPerformanceQueriesPerPool)); + +} +#endif + +#ifdef VK_KHR_get_surface_capabilities2 +static void parse_VkPhysicalDeviceSurfaceInfo2KHR(const char* s, Json::Value& obj, VkPhysicalDeviceSurfaceInfo2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceSurfaceInfo2KHR*)parsePNextChain(obj); + + +} +#endif + +#ifdef VK_KHR_get_surface_capabilities2 +static void parse_VkSurfaceCapabilities2KHR(const char* s, Json::Value& obj, VkSurfaceCapabilities2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSurfaceCapabilities2KHR*)parsePNextChain(obj); + + parse_VkSurfaceCapabilitiesKHR("surfaceCapabilities", obj["surfaceCapabilities"], (o.surfaceCapabilities)); + +} +#endif + +#ifdef VK_KHR_get_surface_capabilities2 +static void parse_VkSurfaceFormat2KHR(const char* s, Json::Value& obj, VkSurfaceFormat2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSurfaceFormat2KHR*)parsePNextChain(obj); + + parse_VkSurfaceFormatKHR("surfaceFormat", obj["surfaceFormat"], (o.surfaceFormat)); + +} +#endif + +#ifdef VK_KHR_get_display_properties2 +static void parse_VkDisplayProperties2KHR(const char* s, Json::Value& obj, VkDisplayProperties2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDisplayProperties2KHR*)parsePNextChain(obj); + + parse_VkDisplayPropertiesKHR("displayProperties", obj["displayProperties"], (o.displayProperties)); + +} +#endif + +#ifdef VK_KHR_get_display_properties2 +static void parse_VkDisplayPlaneProperties2KHR(const char* s, Json::Value& obj, VkDisplayPlaneProperties2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDisplayPlaneProperties2KHR*)parsePNextChain(obj); + + parse_VkDisplayPlanePropertiesKHR("displayPlaneProperties", obj["displayPlaneProperties"], (o.displayPlaneProperties)); + +} +#endif + +#ifdef VK_KHR_get_display_properties2 +static void parse_VkDisplayModeProperties2KHR(const char* s, Json::Value& obj, VkDisplayModeProperties2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDisplayModeProperties2KHR*)parsePNextChain(obj); + + parse_VkDisplayModePropertiesKHR("displayModeProperties", obj["displayModeProperties"], (o.displayModeProperties)); + +} +#endif + +#ifdef VK_KHR_get_display_properties2 +static void parse_VkDisplayPlaneInfo2KHR(const char* s, Json::Value& obj, VkDisplayPlaneInfo2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDisplayPlaneInfo2KHR*)parsePNextChain(obj); + + + parse_uint32_t("planeIndex", obj["planeIndex"], (o.planeIndex)); + +} +#endif + +#ifdef VK_KHR_get_display_properties2 +static void parse_VkDisplayPlaneCapabilities2KHR(const char* s, Json::Value& obj, VkDisplayPlaneCapabilities2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDisplayPlaneCapabilities2KHR*)parsePNextChain(obj); + + parse_VkDisplayPlaneCapabilitiesKHR("capabilities", obj["capabilities"], (o.capabilities)); + +} +#endif + +#ifdef VK_KHR_shader_clock +static void parse_VkPhysicalDeviceShaderClockFeaturesKHR(const char* s, Json::Value& obj, VkPhysicalDeviceShaderClockFeaturesKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceShaderClockFeaturesKHR*)parsePNextChain(obj); + + parse_VkBool32("shaderSubgroupClock", obj["shaderSubgroupClock"], (o.shaderSubgroupClock)); + + parse_VkBool32("shaderDeviceClock", obj["shaderDeviceClock"], (o.shaderDeviceClock)); + +} +#endif + +#ifdef VK_KHR_shader_terminate_invocation +static void parse_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(const char* s, Json::Value& obj, VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*)parsePNextChain(obj); + + parse_VkBool32("shaderTerminateInvocation", obj["shaderTerminateInvocation"], (o.shaderTerminateInvocation)); + +} +#endif + +#ifdef VK_KHR_fragment_shading_rate +static std::map VkFragmentShadingRateCombinerOpKHR_map = { + std::make_pair("VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR", 0), + std::make_pair("VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR", 1), + std::make_pair("VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR", 2), + std::make_pair("VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR", 3), + std::make_pair("VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR", 4), +}; +static void parse_VkFragmentShadingRateCombinerOpKHR(const char* s, Json::Value& obj, VkFragmentShadingRateCombinerOpKHR& o) { + std::string _res = obj.asString(); + o = (VkFragmentShadingRateCombinerOpKHR)VkFragmentShadingRateCombinerOpKHR_map[std::string(_res)]; +} +#endif + +#ifdef VK_KHR_fragment_shading_rate +static void parse_VkFragmentShadingRateAttachmentInfoKHR(const char* s, Json::Value& obj, VkFragmentShadingRateAttachmentInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkFragmentShadingRateAttachmentInfoKHR*)parsePNextChain(obj); + + { + Json::Value& obj_pFragmentShadingRateAttachment = obj["pFragmentShadingRateAttachment"]; + const int sz = obj_pFragmentShadingRateAttachment.size(); + if (obj_pFragmentShadingRateAttachment.size() == 0) { + (o.pFragmentShadingRateAttachment) = nullptr; + } else { + (o.pFragmentShadingRateAttachment) = (VkAttachmentReference2*)s_globalMem.allocate(1, sizeof(VkAttachmentReference2)); + parse_VkAttachmentReference2("pFragmentShadingRateAttachment", obj_pFragmentShadingRateAttachment, const_cast(*(o.pFragmentShadingRateAttachment))); + } + } + + parse_VkExtent2D("shadingRateAttachmentTexelSize", obj["shadingRateAttachmentTexelSize"], (o.shadingRateAttachmentTexelSize)); + +} +#endif + +#ifdef VK_KHR_fragment_shading_rate +static void parse_VkPipelineFragmentShadingRateStateCreateInfoKHR(const char* s, Json::Value& obj, VkPipelineFragmentShadingRateStateCreateInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineFragmentShadingRateStateCreateInfoKHR*)parsePNextChain(obj); + + parse_VkExtent2D("fragmentSize", obj["fragmentSize"], (o.fragmentSize)); + + Json::Value& obj_combinerOps_arr = obj["combinerOps"]; + for (unsigned int i = 0; i < obj_combinerOps_arr.size(); i++) { + parse_VkFragmentShadingRateCombinerOpKHR("combinerOps", obj_combinerOps_arr[i], const_cast((o.combinerOps[i]))); + } + +} +#endif + +#ifdef VK_KHR_fragment_shading_rate +static void parse_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const char* s, Json::Value& obj, VkPhysicalDeviceFragmentShadingRateFeaturesKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceFragmentShadingRateFeaturesKHR*)parsePNextChain(obj); + + parse_VkBool32("pipelineFragmentShadingRate", obj["pipelineFragmentShadingRate"], (o.pipelineFragmentShadingRate)); + + parse_VkBool32("primitiveFragmentShadingRate", obj["primitiveFragmentShadingRate"], (o.primitiveFragmentShadingRate)); + + parse_VkBool32("attachmentFragmentShadingRate", obj["attachmentFragmentShadingRate"], (o.attachmentFragmentShadingRate)); + +} +#endif + +#ifdef VK_KHR_fragment_shading_rate +static void parse_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const char* s, Json::Value& obj, VkPhysicalDeviceFragmentShadingRatePropertiesKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceFragmentShadingRatePropertiesKHR*)parsePNextChain(obj); + + parse_VkExtent2D("minFragmentShadingRateAttachmentTexelSize", obj["minFragmentShadingRateAttachmentTexelSize"], (o.minFragmentShadingRateAttachmentTexelSize)); + + parse_VkExtent2D("maxFragmentShadingRateAttachmentTexelSize", obj["maxFragmentShadingRateAttachmentTexelSize"], (o.maxFragmentShadingRateAttachmentTexelSize)); + + parse_uint32_t("maxFragmentShadingRateAttachmentTexelSizeAspectRatio", obj["maxFragmentShadingRateAttachmentTexelSizeAspectRatio"], (o.maxFragmentShadingRateAttachmentTexelSizeAspectRatio)); + + parse_VkBool32("primitiveFragmentShadingRateWithMultipleViewports", obj["primitiveFragmentShadingRateWithMultipleViewports"], (o.primitiveFragmentShadingRateWithMultipleViewports)); + + parse_VkBool32("layeredShadingRateAttachments", obj["layeredShadingRateAttachments"], (o.layeredShadingRateAttachments)); + + parse_VkBool32("fragmentShadingRateNonTrivialCombinerOps", obj["fragmentShadingRateNonTrivialCombinerOps"], (o.fragmentShadingRateNonTrivialCombinerOps)); + + parse_VkExtent2D("maxFragmentSize", obj["maxFragmentSize"], (o.maxFragmentSize)); + + parse_uint32_t("maxFragmentSizeAspectRatio", obj["maxFragmentSizeAspectRatio"], (o.maxFragmentSizeAspectRatio)); + + parse_uint32_t("maxFragmentShadingRateCoverageSamples", obj["maxFragmentShadingRateCoverageSamples"], (o.maxFragmentShadingRateCoverageSamples)); + + parse_VkSampleCountFlagBits("maxFragmentShadingRateRasterizationSamples", obj["maxFragmentShadingRateRasterizationSamples"], (o.maxFragmentShadingRateRasterizationSamples)); + + parse_VkBool32("fragmentShadingRateWithShaderDepthStencilWrites", obj["fragmentShadingRateWithShaderDepthStencilWrites"], (o.fragmentShadingRateWithShaderDepthStencilWrites)); + + parse_VkBool32("fragmentShadingRateWithSampleMask", obj["fragmentShadingRateWithSampleMask"], (o.fragmentShadingRateWithSampleMask)); + + parse_VkBool32("fragmentShadingRateWithShaderSampleMask", obj["fragmentShadingRateWithShaderSampleMask"], (o.fragmentShadingRateWithShaderSampleMask)); + + parse_VkBool32("fragmentShadingRateWithConservativeRasterization", obj["fragmentShadingRateWithConservativeRasterization"], (o.fragmentShadingRateWithConservativeRasterization)); + + parse_VkBool32("fragmentShadingRateWithFragmentShaderInterlock", obj["fragmentShadingRateWithFragmentShaderInterlock"], (o.fragmentShadingRateWithFragmentShaderInterlock)); + + parse_VkBool32("fragmentShadingRateWithCustomSampleLocations", obj["fragmentShadingRateWithCustomSampleLocations"], (o.fragmentShadingRateWithCustomSampleLocations)); + + parse_VkBool32("fragmentShadingRateStrictMultiplyCombiner", obj["fragmentShadingRateStrictMultiplyCombiner"], (o.fragmentShadingRateStrictMultiplyCombiner)); + +} +#endif + +#ifdef VK_KHR_fragment_shading_rate +static void parse_VkPhysicalDeviceFragmentShadingRateKHR(const char* s, Json::Value& obj, VkPhysicalDeviceFragmentShadingRateKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceFragmentShadingRateKHR*)parsePNextChain(obj); + + parse_VkSampleCountFlags("sampleCounts", obj["sampleCounts"], (o.sampleCounts)); + + parse_VkExtent2D("fragmentSize", obj["fragmentSize"], (o.fragmentSize)); + +} +#endif + +#ifdef VK_KHR_object_refresh +static std::map VkRefreshObjectFlagBitsKHR_map = { +}; +static void parse_VkRefreshObjectFlagBitsKHR(const char* s, Json::Value& obj, VkRefreshObjectFlagBitsKHR& o) { + std::string _res = obj.asString(); + o = (VkRefreshObjectFlagBitsKHR)VkRefreshObjectFlagBitsKHR_map[std::string(_res)]; +} +#endif + +#ifdef VK_KHR_object_refresh +static void parse_VkRefreshObjectFlagsKHR(const char* s, Json::Value& obj, VkRefreshObjectFlagsKHR& o) { + o = (VkRefreshObjectFlagsKHR)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkRefreshObjectFlagBitsKHR)VkRefreshObjectFlagBitsKHR_map[it]; + } +} +#endif + +#ifdef VK_KHR_object_refresh +static void parse_VkRefreshObjectKHR(const char* s, Json::Value& obj, VkRefreshObjectKHR& o) { + + parse_VkObjectType("objectType", obj["objectType"], (o.objectType)); + + parse_uint64_t("objectHandle", obj["objectHandle"], (o.objectHandle)); + + parse_VkRefreshObjectFlagsKHR("flags", obj["flags"], (o.flags)); + +} +#endif + +#ifdef VK_KHR_object_refresh +static void parse_VkRefreshObjectListKHR(const char* s, Json::Value& obj, VkRefreshObjectListKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkRefreshObjectListKHR*)parsePNextChain(obj); + + parse_uint32_t("objectCount", obj["objectCount"], (o.objectCount)); + + (o.pObjects) = (VkRefreshObjectKHR*)s_globalMem.allocate((o.objectCount), sizeof(VkRefreshObjectKHR)); + Json::Value& obj_pObjects = obj["pObjects"]; + if (obj_pObjects.size() == 0) (o.pObjects) = nullptr; + else { + for (unsigned int i = 0; i < (o.objectCount); i++) { + parse_VkRefreshObjectKHR("pObjects", obj_pObjects[i], const_cast((o.pObjects[i]))); + } + } + +} +#endif + +static void parse_VkFlags64(const char* s, Json::Value& obj, VkFlags64& o) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%" SCNd64, &o); +} + +#ifdef VK_KHR_synchronization2 +static std::map VkPipelineStageFlagBits2KHR_map = { + std::make_pair("VK_PIPELINE_STAGE_2_NONE_KHR", 0), + std::make_pair("VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR", 1ULL << 0), + std::make_pair("VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR", 1ULL << 1), + std::make_pair("VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR", 1ULL << 2), + std::make_pair("VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR", 1ULL << 3), + std::make_pair("VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR", 1ULL << 4), + std::make_pair("VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR", 1ULL << 5), + std::make_pair("VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR", 1ULL << 6), + std::make_pair("VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR", 1ULL << 7), + std::make_pair("VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR", 1ULL << 8), + std::make_pair("VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR", 1ULL << 9), + std::make_pair("VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR", 1ULL << 10), + std::make_pair("VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR", 1ULL << 11), + std::make_pair("VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR", 1ULL << 12), + std::make_pair("VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR", 1ULL << 13), + std::make_pair("VK_PIPELINE_STAGE_2_HOST_BIT_KHR", 1ULL << 14), + std::make_pair("VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR", 1ULL << 15), + std::make_pair("VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR", 1ULL << 16), + std::make_pair("VK_PIPELINE_STAGE_2_COPY_BIT_KHR", 1ULL << 32), + std::make_pair("VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR", 1ULL << 33), + std::make_pair("VK_PIPELINE_STAGE_2_BLIT_BIT_KHR", 1ULL << 34), + std::make_pair("VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR", 1ULL << 35), + std::make_pair("VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR", 1ULL << 36), + std::make_pair("VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR", 1ULL << 37), + std::make_pair("VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR", 1ULL << 38), + std::make_pair("VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR", 1ULL << 26), + std::make_pair("VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR", 1ULL << 27), + std::make_pair("VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT", 1ULL << 24), + std::make_pair("VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT", 1ULL << 18), + std::make_pair("VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV", 1ULL << 17), + std::make_pair("VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR", 1ULL << 22), + std::make_pair("VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR", 1ULL << 25), + std::make_pair("VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR", 1ULL << 21), + std::make_pair("VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT", 1ULL << 23), + std::make_pair("VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV", 1ULL << 19), + std::make_pair("VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV", 1ULL << 20), + std::make_pair("VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI", 1ULL << 39), + std::make_pair("VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI", 1ULL << 40), + std::make_pair("VK_PIPELINE_STAGE_2_RESERVED_387_BIT_KHR", 1ULL << 28), +}; +static void parse_VkPipelineStageFlagBits2KHR(const char* s, Json::Value& obj, VkPipelineStageFlagBits2KHR& o) { + std::string _res = obj.asString(); + o = (VkPipelineStageFlagBits2KHR)VkPipelineStageFlagBits2KHR_map[std::string(_res)]; +} +#endif + +#ifdef VK_KHR_synchronization2 +static std::map VkAccessFlagBits2KHR_map = { + std::make_pair("VK_ACCESS_2_NONE_KHR", 0), + std::make_pair("VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR", 1ULL << 0), + std::make_pair("VK_ACCESS_2_INDEX_READ_BIT_KHR", 1ULL << 1), + std::make_pair("VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR", 1ULL << 2), + std::make_pair("VK_ACCESS_2_UNIFORM_READ_BIT_KHR", 1ULL << 3), + std::make_pair("VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR", 1ULL << 4), + std::make_pair("VK_ACCESS_2_SHADER_READ_BIT_KHR", 1ULL << 5), + std::make_pair("VK_ACCESS_2_SHADER_WRITE_BIT_KHR", 1ULL << 6), + std::make_pair("VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR", 1ULL << 7), + std::make_pair("VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR", 1ULL << 8), + std::make_pair("VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR", 1ULL << 9), + std::make_pair("VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR", 1ULL << 10), + std::make_pair("VK_ACCESS_2_TRANSFER_READ_BIT_KHR", 1ULL << 11), + std::make_pair("VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR", 1ULL << 12), + std::make_pair("VK_ACCESS_2_HOST_READ_BIT_KHR", 1ULL << 13), + std::make_pair("VK_ACCESS_2_HOST_WRITE_BIT_KHR", 1ULL << 14), + std::make_pair("VK_ACCESS_2_MEMORY_READ_BIT_KHR", 1ULL << 15), + std::make_pair("VK_ACCESS_2_MEMORY_WRITE_BIT_KHR", 1ULL << 16), + std::make_pair("VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR", 1ULL << 32), + std::make_pair("VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR", 1ULL << 33), + std::make_pair("VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR", 1ULL << 34), + std::make_pair("VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR", 1ULL << 35), + std::make_pair("VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR", 1ULL << 36), + std::make_pair("VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR", 1ULL << 37), + std::make_pair("VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR", 1ULL << 38), + std::make_pair("VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT", 1ULL << 25), + std::make_pair("VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT", 1ULL << 26), + std::make_pair("VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT", 1ULL << 27), + std::make_pair("VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT", 1ULL << 20), + std::make_pair("VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV", 1ULL << 17), + std::make_pair("VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV", 1ULL << 18), + std::make_pair("VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR", 1ULL << 23), + std::make_pair("VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR", 1ULL << 21), + std::make_pair("VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR", 1ULL << 22), + std::make_pair("VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT", 1ULL << 24), + std::make_pair("VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT", 1ULL << 19), + std::make_pair("VK_ACCESS_2_RESERVED_41_BIT_AMD", 1ULL << 41), + std::make_pair("VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI", 1ULL << 39), + std::make_pair("VK_ACCESS_2_RESERVED_387_BIT_KHR", 1ULL << 40), +}; +static void parse_VkAccessFlagBits2KHR(const char* s, Json::Value& obj, VkAccessFlagBits2KHR& o) { + std::string _res = obj.asString(); + o = (VkAccessFlagBits2KHR)VkAccessFlagBits2KHR_map[std::string(_res)]; +} +#endif + +#ifdef VK_KHR_synchronization2 +static std::map VkSubmitFlagBitsKHR_map = { + std::make_pair("VK_SUBMIT_PROTECTED_BIT_KHR", 1UL << 0), +}; +static void parse_VkSubmitFlagBitsKHR(const char* s, Json::Value& obj, VkSubmitFlagBitsKHR& o) { + std::string _res = obj.asString(); + o = (VkSubmitFlagBitsKHR)VkSubmitFlagBitsKHR_map[std::string(_res)]; +} +#endif + +#ifdef VK_KHR_synchronization2 +static void parse_VkPipelineStageFlags2KHR(const char* s, Json::Value& obj, VkPipelineStageFlags2KHR& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%" SCNd64, &o); + } + else { + o = obj.asUInt(); + } +} +#endif + +#ifdef VK_KHR_synchronization2 +static void parse_VkAccessFlags2KHR(const char* s, Json::Value& obj, VkAccessFlags2KHR& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%" SCNd64, &o); + } + else { + o = obj.asUInt(); + } +} +#endif + +#ifdef VK_KHR_synchronization2 +static void parse_VkSubmitFlagsKHR(const char* s, Json::Value& obj, VkSubmitFlagsKHR& o) { + o = (VkSubmitFlagsKHR)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkSubmitFlagBitsKHR)VkSubmitFlagBitsKHR_map[it]; + } +} +#endif + +#ifdef VK_KHR_synchronization2 +static void parse_VkMemoryBarrier2KHR(const char* s, Json::Value& obj, VkMemoryBarrier2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkMemoryBarrier2KHR*)parsePNextChain(obj); + + parse_VkPipelineStageFlags2KHR("srcStageMask", obj["srcStageMask"], (o.srcStageMask)); + + parse_VkAccessFlags2KHR("srcAccessMask", obj["srcAccessMask"], (o.srcAccessMask)); + + parse_VkPipelineStageFlags2KHR("dstStageMask", obj["dstStageMask"], (o.dstStageMask)); + + parse_VkAccessFlags2KHR("dstAccessMask", obj["dstAccessMask"], (o.dstAccessMask)); + +} +#endif + +#ifdef VK_KHR_synchronization2 +static void parse_VkBufferMemoryBarrier2KHR(const char* s, Json::Value& obj, VkBufferMemoryBarrier2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkBufferMemoryBarrier2KHR*)parsePNextChain(obj); + + parse_VkPipelineStageFlags2KHR("srcStageMask", obj["srcStageMask"], (o.srcStageMask)); + + parse_VkAccessFlags2KHR("srcAccessMask", obj["srcAccessMask"], (o.srcAccessMask)); + + parse_VkPipelineStageFlags2KHR("dstStageMask", obj["dstStageMask"], (o.dstStageMask)); + + parse_VkAccessFlags2KHR("dstAccessMask", obj["dstAccessMask"], (o.dstAccessMask)); + + parse_uint32_t("srcQueueFamilyIndex", obj["srcQueueFamilyIndex"], (o.srcQueueFamilyIndex)); + + parse_uint32_t("dstQueueFamilyIndex", obj["dstQueueFamilyIndex"], (o.dstQueueFamilyIndex)); + + + parse_VkDeviceSize("offset", obj["offset"], (o.offset)); + + parse_VkDeviceSize("size", obj["size"], (o.size)); + +} +#endif + +#ifdef VK_KHR_synchronization2 +static void parse_VkImageMemoryBarrier2KHR(const char* s, Json::Value& obj, VkImageMemoryBarrier2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImageMemoryBarrier2KHR*)parsePNextChain(obj); + + parse_VkPipelineStageFlags2KHR("srcStageMask", obj["srcStageMask"], (o.srcStageMask)); + + parse_VkAccessFlags2KHR("srcAccessMask", obj["srcAccessMask"], (o.srcAccessMask)); + + parse_VkPipelineStageFlags2KHR("dstStageMask", obj["dstStageMask"], (o.dstStageMask)); + + parse_VkAccessFlags2KHR("dstAccessMask", obj["dstAccessMask"], (o.dstAccessMask)); + + parse_VkImageLayout("oldLayout", obj["oldLayout"], (o.oldLayout)); + + parse_VkImageLayout("newLayout", obj["newLayout"], (o.newLayout)); + + parse_uint32_t("srcQueueFamilyIndex", obj["srcQueueFamilyIndex"], (o.srcQueueFamilyIndex)); + + parse_uint32_t("dstQueueFamilyIndex", obj["dstQueueFamilyIndex"], (o.dstQueueFamilyIndex)); + + + parse_VkImageSubresourceRange("subresourceRange", obj["subresourceRange"], (o.subresourceRange)); + +} +#endif + +#ifdef VK_KHR_synchronization2 +static void parse_VkDependencyInfoKHR(const char* s, Json::Value& obj, VkDependencyInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDependencyInfoKHR*)parsePNextChain(obj); + + parse_VkDependencyFlags("dependencyFlags", obj["dependencyFlags"], (o.dependencyFlags)); + + parse_uint32_t("memoryBarrierCount", obj["memoryBarrierCount"], (o.memoryBarrierCount)); + + (o.pMemoryBarriers) = (VkMemoryBarrier2KHR*)s_globalMem.allocate((o.memoryBarrierCount), sizeof(VkMemoryBarrier2KHR)); + Json::Value& obj_pMemoryBarriers = obj["pMemoryBarriers"]; + if (obj_pMemoryBarriers.size() == 0) (o.pMemoryBarriers) = nullptr; + else { + for (unsigned int i = 0; i < (o.memoryBarrierCount); i++) { + parse_VkMemoryBarrier2KHR("pMemoryBarriers", obj_pMemoryBarriers[i], const_cast((o.pMemoryBarriers[i]))); + } + } + + parse_uint32_t("bufferMemoryBarrierCount", obj["bufferMemoryBarrierCount"], (o.bufferMemoryBarrierCount)); + + (o.pBufferMemoryBarriers) = (VkBufferMemoryBarrier2KHR*)s_globalMem.allocate((o.bufferMemoryBarrierCount), sizeof(VkBufferMemoryBarrier2KHR)); + Json::Value& obj_pBufferMemoryBarriers = obj["pBufferMemoryBarriers"]; + if (obj_pBufferMemoryBarriers.size() == 0) (o.pBufferMemoryBarriers) = nullptr; + else { + for (unsigned int i = 0; i < (o.bufferMemoryBarrierCount); i++) { + parse_VkBufferMemoryBarrier2KHR("pBufferMemoryBarriers", obj_pBufferMemoryBarriers[i], const_cast((o.pBufferMemoryBarriers[i]))); + } + } + + parse_uint32_t("imageMemoryBarrierCount", obj["imageMemoryBarrierCount"], (o.imageMemoryBarrierCount)); + + (o.pImageMemoryBarriers) = (VkImageMemoryBarrier2KHR*)s_globalMem.allocate((o.imageMemoryBarrierCount), sizeof(VkImageMemoryBarrier2KHR)); + Json::Value& obj_pImageMemoryBarriers = obj["pImageMemoryBarriers"]; + if (obj_pImageMemoryBarriers.size() == 0) (o.pImageMemoryBarriers) = nullptr; + else { + for (unsigned int i = 0; i < (o.imageMemoryBarrierCount); i++) { + parse_VkImageMemoryBarrier2KHR("pImageMemoryBarriers", obj_pImageMemoryBarriers[i], const_cast((o.pImageMemoryBarriers[i]))); + } + } + +} +#endif + +#ifdef VK_KHR_synchronization2 +static void parse_VkSemaphoreSubmitInfoKHR(const char* s, Json::Value& obj, VkSemaphoreSubmitInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSemaphoreSubmitInfoKHR*)parsePNextChain(obj); + + + parse_uint64_t("value", obj["value"], (o.value)); + + parse_VkPipelineStageFlags2KHR("stageMask", obj["stageMask"], (o.stageMask)); + + parse_uint32_t("deviceIndex", obj["deviceIndex"], (o.deviceIndex)); + +} +#endif + +#ifdef VK_KHR_synchronization2 +static void parse_VkCommandBufferSubmitInfoKHR(const char* s, Json::Value& obj, VkCommandBufferSubmitInfoKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkCommandBufferSubmitInfoKHR*)parsePNextChain(obj); + + + parse_uint32_t("deviceMask", obj["deviceMask"], (o.deviceMask)); + +} +#endif + +#ifdef VK_KHR_synchronization2 +static void parse_VkSubmitInfo2KHR(const char* s, Json::Value& obj, VkSubmitInfo2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSubmitInfo2KHR*)parsePNextChain(obj); + + parse_VkSubmitFlagsKHR("flags", obj["flags"], (o.flags)); + + parse_uint32_t("waitSemaphoreInfoCount", obj["waitSemaphoreInfoCount"], (o.waitSemaphoreInfoCount)); + + (o.pWaitSemaphoreInfos) = (VkSemaphoreSubmitInfoKHR*)s_globalMem.allocate((o.waitSemaphoreInfoCount), sizeof(VkSemaphoreSubmitInfoKHR)); + Json::Value& obj_pWaitSemaphoreInfos = obj["pWaitSemaphoreInfos"]; + if (obj_pWaitSemaphoreInfos.size() == 0) (o.pWaitSemaphoreInfos) = nullptr; + else { + for (unsigned int i = 0; i < (o.waitSemaphoreInfoCount); i++) { + parse_VkSemaphoreSubmitInfoKHR("pWaitSemaphoreInfos", obj_pWaitSemaphoreInfos[i], const_cast((o.pWaitSemaphoreInfos[i]))); + } + } + + parse_uint32_t("commandBufferInfoCount", obj["commandBufferInfoCount"], (o.commandBufferInfoCount)); + + (o.pCommandBufferInfos) = (VkCommandBufferSubmitInfoKHR*)s_globalMem.allocate((o.commandBufferInfoCount), sizeof(VkCommandBufferSubmitInfoKHR)); + Json::Value& obj_pCommandBufferInfos = obj["pCommandBufferInfos"]; + if (obj_pCommandBufferInfos.size() == 0) (o.pCommandBufferInfos) = nullptr; + else { + for (unsigned int i = 0; i < (o.commandBufferInfoCount); i++) { + parse_VkCommandBufferSubmitInfoKHR("pCommandBufferInfos", obj_pCommandBufferInfos[i], const_cast((o.pCommandBufferInfos[i]))); + } + } + + parse_uint32_t("signalSemaphoreInfoCount", obj["signalSemaphoreInfoCount"], (o.signalSemaphoreInfoCount)); + + (o.pSignalSemaphoreInfos) = (VkSemaphoreSubmitInfoKHR*)s_globalMem.allocate((o.signalSemaphoreInfoCount), sizeof(VkSemaphoreSubmitInfoKHR)); + Json::Value& obj_pSignalSemaphoreInfos = obj["pSignalSemaphoreInfos"]; + if (obj_pSignalSemaphoreInfos.size() == 0) (o.pSignalSemaphoreInfos) = nullptr; + else { + for (unsigned int i = 0; i < (o.signalSemaphoreInfoCount); i++) { + parse_VkSemaphoreSubmitInfoKHR("pSignalSemaphoreInfos", obj_pSignalSemaphoreInfos[i], const_cast((o.pSignalSemaphoreInfos[i]))); + } + } + +} +#endif + +#ifdef VK_KHR_synchronization2 +static void parse_VkPhysicalDeviceSynchronization2FeaturesKHR(const char* s, Json::Value& obj, VkPhysicalDeviceSynchronization2FeaturesKHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceSynchronization2FeaturesKHR*)parsePNextChain(obj); + + parse_VkBool32("synchronization2", obj["synchronization2"], (o.synchronization2)); + +} +#endif + +#ifdef VK_KHR_synchronization2 +static void parse_VkQueueFamilyCheckpointProperties2NV(const char* s, Json::Value& obj, VkQueueFamilyCheckpointProperties2NV& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkQueueFamilyCheckpointProperties2NV*)parsePNextChain(obj); + + parse_VkPipelineStageFlags2KHR("checkpointExecutionStageMask", obj["checkpointExecutionStageMask"], (o.checkpointExecutionStageMask)); + +} +#endif + +#ifdef VK_KHR_synchronization2 +static void parse_VkCheckpointData2NV(const char* s, Json::Value& obj, VkCheckpointData2NV& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkCheckpointData2NV*)parsePNextChain(obj); + + parse_VkPipelineStageFlags2KHR("stage", obj["stage"], (o.stage)); + + /** Note: Ignoring void* data. **/ + +} +#endif + +#ifdef VK_KHR_copy_commands2 +static void parse_VkBufferCopy2KHR(const char* s, Json::Value& obj, VkBufferCopy2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkBufferCopy2KHR*)parsePNextChain(obj); + + parse_VkDeviceSize("srcOffset", obj["srcOffset"], (o.srcOffset)); + + parse_VkDeviceSize("dstOffset", obj["dstOffset"], (o.dstOffset)); + + parse_VkDeviceSize("size", obj["size"], (o.size)); + +} +#endif + +#ifdef VK_KHR_copy_commands2 +static void parse_VkCopyBufferInfo2KHR(const char* s, Json::Value& obj, VkCopyBufferInfo2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkCopyBufferInfo2KHR*)parsePNextChain(obj); + + + + parse_uint32_t("regionCount", obj["regionCount"], (o.regionCount)); + + (o.pRegions) = (VkBufferCopy2KHR*)s_globalMem.allocate((o.regionCount), sizeof(VkBufferCopy2KHR)); + Json::Value& obj_pRegions = obj["pRegions"]; + if (obj_pRegions.size() == 0) (o.pRegions) = nullptr; + else { + for (unsigned int i = 0; i < (o.regionCount); i++) { + parse_VkBufferCopy2KHR("pRegions", obj_pRegions[i], const_cast((o.pRegions[i]))); + } + } + +} +#endif + +#ifdef VK_KHR_copy_commands2 +static void parse_VkImageCopy2KHR(const char* s, Json::Value& obj, VkImageCopy2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImageCopy2KHR*)parsePNextChain(obj); + + parse_VkImageSubresourceLayers("srcSubresource", obj["srcSubresource"], (o.srcSubresource)); + + parse_VkOffset3D("srcOffset", obj["srcOffset"], (o.srcOffset)); + + parse_VkImageSubresourceLayers("dstSubresource", obj["dstSubresource"], (o.dstSubresource)); + + parse_VkOffset3D("dstOffset", obj["dstOffset"], (o.dstOffset)); + + parse_VkExtent3D("extent", obj["extent"], (o.extent)); + +} +#endif + +#ifdef VK_KHR_copy_commands2 +static void parse_VkCopyImageInfo2KHR(const char* s, Json::Value& obj, VkCopyImageInfo2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkCopyImageInfo2KHR*)parsePNextChain(obj); + + + parse_VkImageLayout("srcImageLayout", obj["srcImageLayout"], (o.srcImageLayout)); + + + parse_VkImageLayout("dstImageLayout", obj["dstImageLayout"], (o.dstImageLayout)); + + parse_uint32_t("regionCount", obj["regionCount"], (o.regionCount)); + + (o.pRegions) = (VkImageCopy2KHR*)s_globalMem.allocate((o.regionCount), sizeof(VkImageCopy2KHR)); + Json::Value& obj_pRegions = obj["pRegions"]; + if (obj_pRegions.size() == 0) (o.pRegions) = nullptr; + else { + for (unsigned int i = 0; i < (o.regionCount); i++) { + parse_VkImageCopy2KHR("pRegions", obj_pRegions[i], const_cast((o.pRegions[i]))); + } + } + +} +#endif + +#ifdef VK_KHR_copy_commands2 +static void parse_VkBufferImageCopy2KHR(const char* s, Json::Value& obj, VkBufferImageCopy2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkBufferImageCopy2KHR*)parsePNextChain(obj); + + parse_VkDeviceSize("bufferOffset", obj["bufferOffset"], (o.bufferOffset)); + + parse_uint32_t("bufferRowLength", obj["bufferRowLength"], (o.bufferRowLength)); + + parse_uint32_t("bufferImageHeight", obj["bufferImageHeight"], (o.bufferImageHeight)); + + parse_VkImageSubresourceLayers("imageSubresource", obj["imageSubresource"], (o.imageSubresource)); + + parse_VkOffset3D("imageOffset", obj["imageOffset"], (o.imageOffset)); + + parse_VkExtent3D("imageExtent", obj["imageExtent"], (o.imageExtent)); + +} +#endif + +#ifdef VK_KHR_copy_commands2 +static void parse_VkCopyBufferToImageInfo2KHR(const char* s, Json::Value& obj, VkCopyBufferToImageInfo2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkCopyBufferToImageInfo2KHR*)parsePNextChain(obj); + + + + parse_VkImageLayout("dstImageLayout", obj["dstImageLayout"], (o.dstImageLayout)); + + parse_uint32_t("regionCount", obj["regionCount"], (o.regionCount)); + + (o.pRegions) = (VkBufferImageCopy2KHR*)s_globalMem.allocate((o.regionCount), sizeof(VkBufferImageCopy2KHR)); + Json::Value& obj_pRegions = obj["pRegions"]; + if (obj_pRegions.size() == 0) (o.pRegions) = nullptr; + else { + for (unsigned int i = 0; i < (o.regionCount); i++) { + parse_VkBufferImageCopy2KHR("pRegions", obj_pRegions[i], const_cast((o.pRegions[i]))); + } + } + +} +#endif + +#ifdef VK_KHR_copy_commands2 +static void parse_VkCopyImageToBufferInfo2KHR(const char* s, Json::Value& obj, VkCopyImageToBufferInfo2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkCopyImageToBufferInfo2KHR*)parsePNextChain(obj); + + + parse_VkImageLayout("srcImageLayout", obj["srcImageLayout"], (o.srcImageLayout)); + + + parse_uint32_t("regionCount", obj["regionCount"], (o.regionCount)); + + (o.pRegions) = (VkBufferImageCopy2KHR*)s_globalMem.allocate((o.regionCount), sizeof(VkBufferImageCopy2KHR)); + Json::Value& obj_pRegions = obj["pRegions"]; + if (obj_pRegions.size() == 0) (o.pRegions) = nullptr; + else { + for (unsigned int i = 0; i < (o.regionCount); i++) { + parse_VkBufferImageCopy2KHR("pRegions", obj_pRegions[i], const_cast((o.pRegions[i]))); + } + } + +} +#endif + +#ifdef VK_KHR_copy_commands2 +static void parse_VkImageBlit2KHR(const char* s, Json::Value& obj, VkImageBlit2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImageBlit2KHR*)parsePNextChain(obj); + + parse_VkImageSubresourceLayers("srcSubresource", obj["srcSubresource"], (o.srcSubresource)); + + Json::Value& obj_srcOffsets_arr = obj["srcOffsets"]; + for (unsigned int i = 0; i < obj_srcOffsets_arr.size(); i++) { + parse_VkOffset3D("srcOffsets", obj_srcOffsets_arr[i], const_cast((o.srcOffsets[i]))); + } + + parse_VkImageSubresourceLayers("dstSubresource", obj["dstSubresource"], (o.dstSubresource)); + + Json::Value& obj_dstOffsets_arr = obj["dstOffsets"]; + for (unsigned int i = 0; i < obj_dstOffsets_arr.size(); i++) { + parse_VkOffset3D("dstOffsets", obj_dstOffsets_arr[i], const_cast((o.dstOffsets[i]))); + } + +} +#endif + +#ifdef VK_KHR_copy_commands2 +static void parse_VkBlitImageInfo2KHR(const char* s, Json::Value& obj, VkBlitImageInfo2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkBlitImageInfo2KHR*)parsePNextChain(obj); + + + parse_VkImageLayout("srcImageLayout", obj["srcImageLayout"], (o.srcImageLayout)); + + + parse_VkImageLayout("dstImageLayout", obj["dstImageLayout"], (o.dstImageLayout)); + + parse_uint32_t("regionCount", obj["regionCount"], (o.regionCount)); + + (o.pRegions) = (VkImageBlit2KHR*)s_globalMem.allocate((o.regionCount), sizeof(VkImageBlit2KHR)); + Json::Value& obj_pRegions = obj["pRegions"]; + if (obj_pRegions.size() == 0) (o.pRegions) = nullptr; + else { + for (unsigned int i = 0; i < (o.regionCount); i++) { + parse_VkImageBlit2KHR("pRegions", obj_pRegions[i], const_cast((o.pRegions[i]))); + } + } + + parse_VkFilter("filter", obj["filter"], (o.filter)); + +} +#endif + +#ifdef VK_KHR_copy_commands2 +static void parse_VkImageResolve2KHR(const char* s, Json::Value& obj, VkImageResolve2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImageResolve2KHR*)parsePNextChain(obj); + + parse_VkImageSubresourceLayers("srcSubresource", obj["srcSubresource"], (o.srcSubresource)); + + parse_VkOffset3D("srcOffset", obj["srcOffset"], (o.srcOffset)); + + parse_VkImageSubresourceLayers("dstSubresource", obj["dstSubresource"], (o.dstSubresource)); + + parse_VkOffset3D("dstOffset", obj["dstOffset"], (o.dstOffset)); + + parse_VkExtent3D("extent", obj["extent"], (o.extent)); + +} +#endif + +#ifdef VK_KHR_copy_commands2 +static void parse_VkResolveImageInfo2KHR(const char* s, Json::Value& obj, VkResolveImageInfo2KHR& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkResolveImageInfo2KHR*)parsePNextChain(obj); + + + parse_VkImageLayout("srcImageLayout", obj["srcImageLayout"], (o.srcImageLayout)); + + + parse_VkImageLayout("dstImageLayout", obj["dstImageLayout"], (o.dstImageLayout)); + + parse_uint32_t("regionCount", obj["regionCount"], (o.regionCount)); + + (o.pRegions) = (VkImageResolve2KHR*)s_globalMem.allocate((o.regionCount), sizeof(VkImageResolve2KHR)); + Json::Value& obj_pRegions = obj["pRegions"]; + if (obj_pRegions.size() == 0) (o.pRegions) = nullptr; + else { + for (unsigned int i = 0; i < (o.regionCount); i++) { + parse_VkImageResolve2KHR("pRegions", obj_pRegions[i], const_cast((o.pRegions[i]))); + } + } + +} +#endif + +#ifdef VK_EXT_texture_compression_astc_hdr +static void parse_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("textureCompressionASTC_HDR", obj["textureCompressionASTC_HDR"], (o.textureCompressionASTC_HDR)); + +} +#endif + +#ifdef VK_EXT_astc_decode_mode +static void parse_VkImageViewASTCDecodeModeEXT(const char* s, Json::Value& obj, VkImageViewASTCDecodeModeEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImageViewASTCDecodeModeEXT*)parsePNextChain(obj); + + parse_VkFormat("decodeMode", obj["decodeMode"], (o.decodeMode)); + +} +#endif + +#ifdef VK_EXT_astc_decode_mode +static void parse_VkPhysicalDeviceASTCDecodeFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceASTCDecodeFeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceASTCDecodeFeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("decodeModeSharedExponent", obj["decodeModeSharedExponent"], (o.decodeModeSharedExponent)); + +} +#endif + +#ifdef VK_EXT_display_surface_counter +static std::map VkSurfaceCounterFlagBitsEXT_map = { + std::make_pair("VK_SURFACE_COUNTER_VBLANK_BIT_EXT", 1UL << 0), +}; +static void parse_VkSurfaceCounterFlagBitsEXT(const char* s, Json::Value& obj, VkSurfaceCounterFlagBitsEXT& o) { + std::string _res = obj.asString(); + o = (VkSurfaceCounterFlagBitsEXT)VkSurfaceCounterFlagBitsEXT_map[std::string(_res)]; +} +#endif + +#ifdef VK_EXT_display_surface_counter +static void parse_VkSurfaceCounterFlagsEXT(const char* s, Json::Value& obj, VkSurfaceCounterFlagsEXT& o) { + o = (VkSurfaceCounterFlagsEXT)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkSurfaceCounterFlagBitsEXT)VkSurfaceCounterFlagBitsEXT_map[it]; + } +} +#endif + +#ifdef VK_EXT_display_surface_counter +static void parse_VkSurfaceCapabilities2EXT(const char* s, Json::Value& obj, VkSurfaceCapabilities2EXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSurfaceCapabilities2EXT*)parsePNextChain(obj); + + parse_uint32_t("minImageCount", obj["minImageCount"], (o.minImageCount)); + + parse_uint32_t("maxImageCount", obj["maxImageCount"], (o.maxImageCount)); + + parse_VkExtent2D("currentExtent", obj["currentExtent"], (o.currentExtent)); + + parse_VkExtent2D("minImageExtent", obj["minImageExtent"], (o.minImageExtent)); + + parse_VkExtent2D("maxImageExtent", obj["maxImageExtent"], (o.maxImageExtent)); + + parse_uint32_t("maxImageArrayLayers", obj["maxImageArrayLayers"], (o.maxImageArrayLayers)); + + parse_VkSurfaceTransformFlagsKHR("supportedTransforms", obj["supportedTransforms"], (o.supportedTransforms)); + + parse_VkSurfaceTransformFlagBitsKHR("currentTransform", obj["currentTransform"], (o.currentTransform)); + + parse_VkCompositeAlphaFlagsKHR("supportedCompositeAlpha", obj["supportedCompositeAlpha"], (o.supportedCompositeAlpha)); + + parse_VkImageUsageFlags("supportedUsageFlags", obj["supportedUsageFlags"], (o.supportedUsageFlags)); + + parse_VkSurfaceCounterFlagsEXT("supportedSurfaceCounters", obj["supportedSurfaceCounters"], (o.supportedSurfaceCounters)); + +} +#endif + +#ifdef VK_EXT_display_control +static std::map VkDisplayPowerStateEXT_map = { + std::make_pair("VK_DISPLAY_POWER_STATE_OFF_EXT", 0), + std::make_pair("VK_DISPLAY_POWER_STATE_SUSPEND_EXT", 1), + std::make_pair("VK_DISPLAY_POWER_STATE_ON_EXT", 2), +}; +static void parse_VkDisplayPowerStateEXT(const char* s, Json::Value& obj, VkDisplayPowerStateEXT& o) { + std::string _res = obj.asString(); + o = (VkDisplayPowerStateEXT)VkDisplayPowerStateEXT_map[std::string(_res)]; +} +#endif + +#ifdef VK_EXT_display_control +static std::map VkDeviceEventTypeEXT_map = { + std::make_pair("VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT", 0), +}; +static void parse_VkDeviceEventTypeEXT(const char* s, Json::Value& obj, VkDeviceEventTypeEXT& o) { + std::string _res = obj.asString(); + o = (VkDeviceEventTypeEXT)VkDeviceEventTypeEXT_map[std::string(_res)]; +} +#endif + +#ifdef VK_EXT_display_control +static std::map VkDisplayEventTypeEXT_map = { + std::make_pair("VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT", 0), +}; +static void parse_VkDisplayEventTypeEXT(const char* s, Json::Value& obj, VkDisplayEventTypeEXT& o) { + std::string _res = obj.asString(); + o = (VkDisplayEventTypeEXT)VkDisplayEventTypeEXT_map[std::string(_res)]; +} +#endif + +#ifdef VK_EXT_display_control +static void parse_VkDisplayPowerInfoEXT(const char* s, Json::Value& obj, VkDisplayPowerInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDisplayPowerInfoEXT*)parsePNextChain(obj); + + parse_VkDisplayPowerStateEXT("powerState", obj["powerState"], (o.powerState)); + +} +#endif + +#ifdef VK_EXT_display_control +static void parse_VkDeviceEventInfoEXT(const char* s, Json::Value& obj, VkDeviceEventInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDeviceEventInfoEXT*)parsePNextChain(obj); + + parse_VkDeviceEventTypeEXT("deviceEvent", obj["deviceEvent"], (o.deviceEvent)); + +} +#endif + +#ifdef VK_EXT_display_control +static void parse_VkDisplayEventInfoEXT(const char* s, Json::Value& obj, VkDisplayEventInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDisplayEventInfoEXT*)parsePNextChain(obj); + + parse_VkDisplayEventTypeEXT("displayEvent", obj["displayEvent"], (o.displayEvent)); + +} +#endif + +#ifdef VK_EXT_display_control +static void parse_VkSwapchainCounterCreateInfoEXT(const char* s, Json::Value& obj, VkSwapchainCounterCreateInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSwapchainCounterCreateInfoEXT*)parsePNextChain(obj); + + parse_VkSurfaceCounterFlagsEXT("surfaceCounters", obj["surfaceCounters"], (o.surfaceCounters)); + +} +#endif + +#ifdef VK_EXT_discard_rectangles +static std::map VkDiscardRectangleModeEXT_map = { + std::make_pair("VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT", 0), + std::make_pair("VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT", 1), +}; +static void parse_VkDiscardRectangleModeEXT(const char* s, Json::Value& obj, VkDiscardRectangleModeEXT& o) { + std::string _res = obj.asString(); + o = (VkDiscardRectangleModeEXT)VkDiscardRectangleModeEXT_map[std::string(_res)]; +} +#endif + +#ifdef VK_EXT_discard_rectangles +static void parse_VkPipelineDiscardRectangleStateCreateFlagsEXT(const char* s, Json::Value& obj, VkPipelineDiscardRectangleStateCreateFlagsEXT& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} +#endif + +#ifdef VK_EXT_discard_rectangles +static void parse_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceDiscardRectanglePropertiesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceDiscardRectanglePropertiesEXT*)parsePNextChain(obj); + + parse_uint32_t("maxDiscardRectangles", obj["maxDiscardRectangles"], (o.maxDiscardRectangles)); + +} +#endif + +#ifdef VK_EXT_discard_rectangles +static void parse_VkPipelineDiscardRectangleStateCreateInfoEXT(const char* s, Json::Value& obj, VkPipelineDiscardRectangleStateCreateInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineDiscardRectangleStateCreateInfoEXT*)parsePNextChain(obj); + + parse_VkPipelineDiscardRectangleStateCreateFlagsEXT("flags", obj["flags"], (o.flags)); + + parse_VkDiscardRectangleModeEXT("discardRectangleMode", obj["discardRectangleMode"], (o.discardRectangleMode)); + + parse_uint32_t("discardRectangleCount", obj["discardRectangleCount"], (o.discardRectangleCount)); + + (o.pDiscardRectangles) = (VkRect2D*)s_globalMem.allocate((o.discardRectangleCount), sizeof(VkRect2D)); + Json::Value& obj_pDiscardRectangles = obj["pDiscardRectangles"]; + if (obj_pDiscardRectangles.size() == 0) (o.pDiscardRectangles) = nullptr; + else { + for (unsigned int i = 0; i < (o.discardRectangleCount); i++) { + parse_VkRect2D("pDiscardRectangles", obj_pDiscardRectangles[i], const_cast((o.pDiscardRectangles[i]))); + } + } + +} +#endif + +#ifdef VK_EXT_conservative_rasterization +static std::map VkConservativeRasterizationModeEXT_map = { + std::make_pair("VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT", 0), + std::make_pair("VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT", 1), + std::make_pair("VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT", 2), +}; +static void parse_VkConservativeRasterizationModeEXT(const char* s, Json::Value& obj, VkConservativeRasterizationModeEXT& o) { + std::string _res = obj.asString(); + o = (VkConservativeRasterizationModeEXT)VkConservativeRasterizationModeEXT_map[std::string(_res)]; +} +#endif + +#ifdef VK_EXT_conservative_rasterization +static void parse_VkPipelineRasterizationConservativeStateCreateFlagsEXT(const char* s, Json::Value& obj, VkPipelineRasterizationConservativeStateCreateFlagsEXT& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} +#endif + +#ifdef VK_EXT_conservative_rasterization +static void parse_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceConservativeRasterizationPropertiesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceConservativeRasterizationPropertiesEXT*)parsePNextChain(obj); + + parse_float("primitiveOverestimationSize", obj["primitiveOverestimationSize"], (o.primitiveOverestimationSize)); + + parse_float("maxExtraPrimitiveOverestimationSize", obj["maxExtraPrimitiveOverestimationSize"], (o.maxExtraPrimitiveOverestimationSize)); + + parse_float("extraPrimitiveOverestimationSizeGranularity", obj["extraPrimitiveOverestimationSizeGranularity"], (o.extraPrimitiveOverestimationSizeGranularity)); + + parse_VkBool32("primitiveUnderestimation", obj["primitiveUnderestimation"], (o.primitiveUnderestimation)); + + parse_VkBool32("conservativePointAndLineRasterization", obj["conservativePointAndLineRasterization"], (o.conservativePointAndLineRasterization)); + + parse_VkBool32("degenerateTrianglesRasterized", obj["degenerateTrianglesRasterized"], (o.degenerateTrianglesRasterized)); + + parse_VkBool32("degenerateLinesRasterized", obj["degenerateLinesRasterized"], (o.degenerateLinesRasterized)); + + parse_VkBool32("fullyCoveredFragmentShaderInputVariable", obj["fullyCoveredFragmentShaderInputVariable"], (o.fullyCoveredFragmentShaderInputVariable)); + + parse_VkBool32("conservativeRasterizationPostDepthCoverage", obj["conservativeRasterizationPostDepthCoverage"], (o.conservativeRasterizationPostDepthCoverage)); + +} +#endif + +#ifdef VK_EXT_conservative_rasterization +static void parse_VkPipelineRasterizationConservativeStateCreateInfoEXT(const char* s, Json::Value& obj, VkPipelineRasterizationConservativeStateCreateInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineRasterizationConservativeStateCreateInfoEXT*)parsePNextChain(obj); + + parse_VkPipelineRasterizationConservativeStateCreateFlagsEXT("flags", obj["flags"], (o.flags)); + + parse_VkConservativeRasterizationModeEXT("conservativeRasterizationMode", obj["conservativeRasterizationMode"], (o.conservativeRasterizationMode)); + + parse_float("extraPrimitiveOverestimationSize", obj["extraPrimitiveOverestimationSize"], (o.extraPrimitiveOverestimationSize)); + +} +#endif + +#ifdef VK_EXT_depth_clip_enable +static void parse_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(const char* s, Json::Value& obj, VkPipelineRasterizationDepthClipStateCreateFlagsEXT& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} +#endif + +#ifdef VK_EXT_depth_clip_enable +static void parse_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceDepthClipEnableFeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceDepthClipEnableFeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("depthClipEnable", obj["depthClipEnable"], (o.depthClipEnable)); + +} +#endif + +#ifdef VK_EXT_depth_clip_enable +static void parse_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const char* s, Json::Value& obj, VkPipelineRasterizationDepthClipStateCreateInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineRasterizationDepthClipStateCreateInfoEXT*)parsePNextChain(obj); + + parse_VkPipelineRasterizationDepthClipStateCreateFlagsEXT("flags", obj["flags"], (o.flags)); + + parse_VkBool32("depthClipEnable", obj["depthClipEnable"], (o.depthClipEnable)); + +} +#endif + +#ifdef VK_EXT_hdr_metadata +static void parse_VkXYColorEXT(const char* s, Json::Value& obj, VkXYColorEXT& o) { + + parse_float("x", obj["x"], (o.x)); + + parse_float("y", obj["y"], (o.y)); + +} +#endif + +#ifdef VK_EXT_hdr_metadata +static void parse_VkHdrMetadataEXT(const char* s, Json::Value& obj, VkHdrMetadataEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkHdrMetadataEXT*)parsePNextChain(obj); + + parse_VkXYColorEXT("displayPrimaryRed", obj["displayPrimaryRed"], (o.displayPrimaryRed)); + + parse_VkXYColorEXT("displayPrimaryGreen", obj["displayPrimaryGreen"], (o.displayPrimaryGreen)); + + parse_VkXYColorEXT("displayPrimaryBlue", obj["displayPrimaryBlue"], (o.displayPrimaryBlue)); + + parse_VkXYColorEXT("whitePoint", obj["whitePoint"], (o.whitePoint)); + + parse_float("maxLuminance", obj["maxLuminance"], (o.maxLuminance)); + + parse_float("minLuminance", obj["minLuminance"], (o.minLuminance)); + + parse_float("maxContentLightLevel", obj["maxContentLightLevel"], (o.maxContentLightLevel)); + + parse_float("maxFrameAverageLightLevel", obj["maxFrameAverageLightLevel"], (o.maxFrameAverageLightLevel)); + +} +#endif + +#ifdef VK_EXT_debug_utils +static void parse_VkDebugUtilsMessengerEXT(const char* s, Json::Value& obj, VkDebugUtilsMessengerEXT& o) { +// std::string _res = obj.asString(); +} +#endif + +#ifdef VK_EXT_debug_utils +static std::map VkDebugUtilsMessageSeverityFlagBitsEXT_map = { + std::make_pair("VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT", 1UL << 0), + std::make_pair("VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT", 1UL << 4), + std::make_pair("VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT", 1UL << 8), + std::make_pair("VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT", 1UL << 12), +}; +static void parse_VkDebugUtilsMessageSeverityFlagBitsEXT(const char* s, Json::Value& obj, VkDebugUtilsMessageSeverityFlagBitsEXT& o) { + std::string _res = obj.asString(); + o = (VkDebugUtilsMessageSeverityFlagBitsEXT)VkDebugUtilsMessageSeverityFlagBitsEXT_map[std::string(_res)]; +} +#endif + +#ifdef VK_EXT_debug_utils +static std::map VkDebugUtilsMessageTypeFlagBitsEXT_map = { + std::make_pair("VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT", 1UL << 0), + std::make_pair("VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT", 1UL << 1), + std::make_pair("VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT", 1UL << 2), +}; +static void parse_VkDebugUtilsMessageTypeFlagBitsEXT(const char* s, Json::Value& obj, VkDebugUtilsMessageTypeFlagBitsEXT& o) { + std::string _res = obj.asString(); + o = (VkDebugUtilsMessageTypeFlagBitsEXT)VkDebugUtilsMessageTypeFlagBitsEXT_map[std::string(_res)]; +} +#endif + +#ifdef VK_EXT_debug_utils +static void parse_VkDebugUtilsMessengerCallbackDataFlagsEXT(const char* s, Json::Value& obj, VkDebugUtilsMessengerCallbackDataFlagsEXT& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} +#endif + +#ifdef VK_EXT_debug_utils +static void parse_VkDebugUtilsMessageTypeFlagsEXT(const char* s, Json::Value& obj, VkDebugUtilsMessageTypeFlagsEXT& o) { + o = (VkDebugUtilsMessageTypeFlagsEXT)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkDebugUtilsMessageTypeFlagBitsEXT)VkDebugUtilsMessageTypeFlagBitsEXT_map[it]; + } +} +#endif + +#ifdef VK_EXT_debug_utils +static void parse_VkDebugUtilsMessageSeverityFlagsEXT(const char* s, Json::Value& obj, VkDebugUtilsMessageSeverityFlagsEXT& o) { + o = (VkDebugUtilsMessageSeverityFlagsEXT)0; + std::string _res = obj.asString(); + std::vector bitmasks; + std::istringstream inputStream(_res); + std::string tempStr; + while (getline(inputStream, tempStr, '|')) { + tempStr.erase(std::remove_if(tempStr.begin(), tempStr.end(), isspace), tempStr.end()); + bitmasks.push_back(tempStr); + } + for (auto& it : bitmasks) { + o |= (VkDebugUtilsMessageSeverityFlagBitsEXT)VkDebugUtilsMessageSeverityFlagBitsEXT_map[it]; + } +} +#endif + +#ifdef VK_EXT_debug_utils +static void parse_VkDebugUtilsMessengerCreateFlagsEXT(const char* s, Json::Value& obj, VkDebugUtilsMessengerCreateFlagsEXT& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} +#endif + +#ifdef VK_EXT_debug_utils +static void parse_VkDebugUtilsLabelEXT(const char* s, Json::Value& obj, VkDebugUtilsLabelEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDebugUtilsLabelEXT*)parsePNextChain(obj); + + /** TODO: Handle this - pLabelName **/ + + Json::Value& obj_color_arr = obj["color"]; + for (unsigned int i = 0; i < obj_color_arr.size(); i++) { + parse_float("color", obj_color_arr[i], const_cast((o.color[i]))); + } + +} +#endif + +#ifdef VK_EXT_debug_utils +static void parse_VkDebugUtilsObjectNameInfoEXT(const char* s, Json::Value& obj, VkDebugUtilsObjectNameInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDebugUtilsObjectNameInfoEXT*)parsePNextChain(obj); + + parse_VkObjectType("objectType", obj["objectType"], (o.objectType)); + + parse_uint64_t("objectHandle", obj["objectHandle"], (o.objectHandle)); + + /** TODO: Handle this - pObjectName **/ + +} +#endif + +#ifdef VK_EXT_debug_utils +static void parse_VkDebugUtilsMessengerCallbackDataEXT(const char* s, Json::Value& obj, VkDebugUtilsMessengerCallbackDataEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDebugUtilsMessengerCallbackDataEXT*)parsePNextChain(obj); + + parse_VkDebugUtilsMessengerCallbackDataFlagsEXT("flags", obj["flags"], (o.flags)); + + /** TODO: Handle this - pMessageIdName **/ + + parse_int32_t("messageIdNumber", obj["messageIdNumber"], (o.messageIdNumber)); + + /** TODO: Handle this - pMessage **/ + + parse_uint32_t("queueLabelCount", obj["queueLabelCount"], (o.queueLabelCount)); + + (o.pQueueLabels) = (VkDebugUtilsLabelEXT*)s_globalMem.allocate((o.queueLabelCount), sizeof(VkDebugUtilsLabelEXT)); + Json::Value& obj_pQueueLabels = obj["pQueueLabels"]; + if (obj_pQueueLabels.size() == 0) (o.pQueueLabels) = nullptr; + else { + for (unsigned int i = 0; i < (o.queueLabelCount); i++) { + parse_VkDebugUtilsLabelEXT("pQueueLabels", obj_pQueueLabels[i], const_cast((o.pQueueLabels[i]))); + } + } + + parse_uint32_t("cmdBufLabelCount", obj["cmdBufLabelCount"], (o.cmdBufLabelCount)); + + (o.pCmdBufLabels) = (VkDebugUtilsLabelEXT*)s_globalMem.allocate((o.cmdBufLabelCount), sizeof(VkDebugUtilsLabelEXT)); + Json::Value& obj_pCmdBufLabels = obj["pCmdBufLabels"]; + if (obj_pCmdBufLabels.size() == 0) (o.pCmdBufLabels) = nullptr; + else { + for (unsigned int i = 0; i < (o.cmdBufLabelCount); i++) { + parse_VkDebugUtilsLabelEXT("pCmdBufLabels", obj_pCmdBufLabels[i], const_cast((o.pCmdBufLabels[i]))); + } + } + + parse_uint32_t("objectCount", obj["objectCount"], (o.objectCount)); + + (o.pObjects) = (VkDebugUtilsObjectNameInfoEXT*)s_globalMem.allocate((o.objectCount), sizeof(VkDebugUtilsObjectNameInfoEXT)); + Json::Value& obj_pObjects = obj["pObjects"]; + if (obj_pObjects.size() == 0) (o.pObjects) = nullptr; + else { + for (unsigned int i = 0; i < (o.objectCount); i++) { + parse_VkDebugUtilsObjectNameInfoEXT("pObjects", obj_pObjects[i], const_cast((o.pObjects[i]))); + } + } + +} +#endif + +#ifdef VK_EXT_debug_utils +static void parse_VkDebugUtilsMessengerCreateInfoEXT(const char* s, Json::Value& obj, VkDebugUtilsMessengerCreateInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDebugUtilsMessengerCreateInfoEXT*)parsePNextChain(obj); + + parse_VkDebugUtilsMessengerCreateFlagsEXT("flags", obj["flags"], (o.flags)); + + parse_VkDebugUtilsMessageSeverityFlagsEXT("messageSeverity", obj["messageSeverity"], (o.messageSeverity)); + + parse_VkDebugUtilsMessageTypeFlagsEXT("messageType", obj["messageType"], (o.messageType)); + + /** Note: Ignoring function pointer (PFN_vkDebugUtilsMessengerCallbackEXT). **/ + + /** Note: Ignoring void* data. **/ + +} +#endif + +#ifdef VK_EXT_debug_utils +static void parse_VkDebugUtilsObjectTagInfoEXT(const char* s, Json::Value& obj, VkDebugUtilsObjectTagInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDebugUtilsObjectTagInfoEXT*)parsePNextChain(obj); + + parse_VkObjectType("objectType", obj["objectType"], (o.objectType)); + + parse_uint64_t("objectHandle", obj["objectHandle"], (o.objectHandle)); + + parse_uint64_t("tagName", obj["tagName"], (o.tagName)); + + parse_size_t("tagSize", obj["tagSize"], (o.tagSize)); + + /** Note: Ignoring void* data. **/ + +} +#endif + +#ifdef VK_EXT_sample_locations +static void parse_VkSampleLocationEXT(const char* s, Json::Value& obj, VkSampleLocationEXT& o) { + + parse_float("x", obj["x"], (o.x)); + + parse_float("y", obj["y"], (o.y)); + +} +#endif + +#ifdef VK_EXT_sample_locations +static void parse_VkSampleLocationsInfoEXT(const char* s, Json::Value& obj, VkSampleLocationsInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSampleLocationsInfoEXT*)parsePNextChain(obj); + + parse_VkSampleCountFlagBits("sampleLocationsPerPixel", obj["sampleLocationsPerPixel"], (o.sampleLocationsPerPixel)); + + parse_VkExtent2D("sampleLocationGridSize", obj["sampleLocationGridSize"], (o.sampleLocationGridSize)); + + parse_uint32_t("sampleLocationsCount", obj["sampleLocationsCount"], (o.sampleLocationsCount)); + + (o.pSampleLocations) = (VkSampleLocationEXT*)s_globalMem.allocate((o.sampleLocationsCount), sizeof(VkSampleLocationEXT)); + Json::Value& obj_pSampleLocations = obj["pSampleLocations"]; + if (obj_pSampleLocations.size() == 0) (o.pSampleLocations) = nullptr; + else { + for (unsigned int i = 0; i < (o.sampleLocationsCount); i++) { + parse_VkSampleLocationEXT("pSampleLocations", obj_pSampleLocations[i], const_cast((o.pSampleLocations[i]))); + } + } + +} +#endif + +#ifdef VK_EXT_sample_locations +static void parse_VkAttachmentSampleLocationsEXT(const char* s, Json::Value& obj, VkAttachmentSampleLocationsEXT& o) { + + parse_uint32_t("attachmentIndex", obj["attachmentIndex"], (o.attachmentIndex)); + + parse_VkSampleLocationsInfoEXT("sampleLocationsInfo", obj["sampleLocationsInfo"], (o.sampleLocationsInfo)); + +} +#endif + +#ifdef VK_EXT_sample_locations +static void parse_VkSubpassSampleLocationsEXT(const char* s, Json::Value& obj, VkSubpassSampleLocationsEXT& o) { + + parse_uint32_t("subpassIndex", obj["subpassIndex"], (o.subpassIndex)); + + parse_VkSampleLocationsInfoEXT("sampleLocationsInfo", obj["sampleLocationsInfo"], (o.sampleLocationsInfo)); + +} +#endif + +#ifdef VK_EXT_sample_locations +static void parse_VkRenderPassSampleLocationsBeginInfoEXT(const char* s, Json::Value& obj, VkRenderPassSampleLocationsBeginInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkRenderPassSampleLocationsBeginInfoEXT*)parsePNextChain(obj); + + parse_uint32_t("attachmentInitialSampleLocationsCount", obj["attachmentInitialSampleLocationsCount"], (o.attachmentInitialSampleLocationsCount)); + + (o.pAttachmentInitialSampleLocations) = (VkAttachmentSampleLocationsEXT*)s_globalMem.allocate((o.attachmentInitialSampleLocationsCount), sizeof(VkAttachmentSampleLocationsEXT)); + Json::Value& obj_pAttachmentInitialSampleLocations = obj["pAttachmentInitialSampleLocations"]; + if (obj_pAttachmentInitialSampleLocations.size() == 0) (o.pAttachmentInitialSampleLocations) = nullptr; + else { + for (unsigned int i = 0; i < (o.attachmentInitialSampleLocationsCount); i++) { + parse_VkAttachmentSampleLocationsEXT("pAttachmentInitialSampleLocations", obj_pAttachmentInitialSampleLocations[i], const_cast((o.pAttachmentInitialSampleLocations[i]))); + } + } + + parse_uint32_t("postSubpassSampleLocationsCount", obj["postSubpassSampleLocationsCount"], (o.postSubpassSampleLocationsCount)); + + (o.pPostSubpassSampleLocations) = (VkSubpassSampleLocationsEXT*)s_globalMem.allocate((o.postSubpassSampleLocationsCount), sizeof(VkSubpassSampleLocationsEXT)); + Json::Value& obj_pPostSubpassSampleLocations = obj["pPostSubpassSampleLocations"]; + if (obj_pPostSubpassSampleLocations.size() == 0) (o.pPostSubpassSampleLocations) = nullptr; + else { + for (unsigned int i = 0; i < (o.postSubpassSampleLocationsCount); i++) { + parse_VkSubpassSampleLocationsEXT("pPostSubpassSampleLocations", obj_pPostSubpassSampleLocations[i], const_cast((o.pPostSubpassSampleLocations[i]))); + } + } + +} +#endif + +#ifdef VK_EXT_sample_locations +static void parse_VkPipelineSampleLocationsStateCreateInfoEXT(const char* s, Json::Value& obj, VkPipelineSampleLocationsStateCreateInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineSampleLocationsStateCreateInfoEXT*)parsePNextChain(obj); + + parse_VkBool32("sampleLocationsEnable", obj["sampleLocationsEnable"], (o.sampleLocationsEnable)); + + parse_VkSampleLocationsInfoEXT("sampleLocationsInfo", obj["sampleLocationsInfo"], (o.sampleLocationsInfo)); + +} +#endif + +#ifdef VK_EXT_sample_locations +static void parse_VkPhysicalDeviceSampleLocationsPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceSampleLocationsPropertiesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceSampleLocationsPropertiesEXT*)parsePNextChain(obj); + + parse_VkSampleCountFlags("sampleLocationSampleCounts", obj["sampleLocationSampleCounts"], (o.sampleLocationSampleCounts)); + + parse_VkExtent2D("maxSampleLocationGridSize", obj["maxSampleLocationGridSize"], (o.maxSampleLocationGridSize)); + + Json::Value& obj_sampleLocationCoordinateRange_arr = obj["sampleLocationCoordinateRange"]; + for (unsigned int i = 0; i < obj_sampleLocationCoordinateRange_arr.size(); i++) { + parse_float("sampleLocationCoordinateRange", obj_sampleLocationCoordinateRange_arr[i], const_cast((o.sampleLocationCoordinateRange[i]))); + } + + parse_uint32_t("sampleLocationSubPixelBits", obj["sampleLocationSubPixelBits"], (o.sampleLocationSubPixelBits)); + + parse_VkBool32("variableSampleLocations", obj["variableSampleLocations"], (o.variableSampleLocations)); + +} +#endif + +#ifdef VK_EXT_sample_locations +static void parse_VkMultisamplePropertiesEXT(const char* s, Json::Value& obj, VkMultisamplePropertiesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkMultisamplePropertiesEXT*)parsePNextChain(obj); + + parse_VkExtent2D("maxSampleLocationGridSize", obj["maxSampleLocationGridSize"], (o.maxSampleLocationGridSize)); + +} +#endif + +#ifdef VK_EXT_blend_operation_advanced +static std::map VkBlendOverlapEXT_map = { + std::make_pair("VK_BLEND_OVERLAP_UNCORRELATED_EXT", 0), + std::make_pair("VK_BLEND_OVERLAP_DISJOINT_EXT", 1), + std::make_pair("VK_BLEND_OVERLAP_CONJOINT_EXT", 2), +}; +static void parse_VkBlendOverlapEXT(const char* s, Json::Value& obj, VkBlendOverlapEXT& o) { + std::string _res = obj.asString(); + o = (VkBlendOverlapEXT)VkBlendOverlapEXT_map[std::string(_res)]; +} +#endif + +#ifdef VK_EXT_blend_operation_advanced +static void parse_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("advancedBlendCoherentOperations", obj["advancedBlendCoherentOperations"], (o.advancedBlendCoherentOperations)); + +} +#endif + +#ifdef VK_EXT_blend_operation_advanced +static void parse_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*)parsePNextChain(obj); + + parse_uint32_t("advancedBlendMaxColorAttachments", obj["advancedBlendMaxColorAttachments"], (o.advancedBlendMaxColorAttachments)); + + parse_VkBool32("advancedBlendIndependentBlend", obj["advancedBlendIndependentBlend"], (o.advancedBlendIndependentBlend)); + + parse_VkBool32("advancedBlendNonPremultipliedSrcColor", obj["advancedBlendNonPremultipliedSrcColor"], (o.advancedBlendNonPremultipliedSrcColor)); + + parse_VkBool32("advancedBlendNonPremultipliedDstColor", obj["advancedBlendNonPremultipliedDstColor"], (o.advancedBlendNonPremultipliedDstColor)); + + parse_VkBool32("advancedBlendCorrelatedOverlap", obj["advancedBlendCorrelatedOverlap"], (o.advancedBlendCorrelatedOverlap)); + + parse_VkBool32("advancedBlendAllOperations", obj["advancedBlendAllOperations"], (o.advancedBlendAllOperations)); + +} +#endif + +#ifdef VK_EXT_blend_operation_advanced +static void parse_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const char* s, Json::Value& obj, VkPipelineColorBlendAdvancedStateCreateInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineColorBlendAdvancedStateCreateInfoEXT*)parsePNextChain(obj); + + parse_VkBool32("srcPremultiplied", obj["srcPremultiplied"], (o.srcPremultiplied)); + + parse_VkBool32("dstPremultiplied", obj["dstPremultiplied"], (o.dstPremultiplied)); + + parse_VkBlendOverlapEXT("blendOverlap", obj["blendOverlap"], (o.blendOverlap)); + +} +#endif + +static std::map VkFormatFeatureFlagBits2KHR_map = { + std::make_pair("VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR", 1ULL << 0), + std::make_pair("VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR", 1ULL << 1), + std::make_pair("VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR", 1ULL << 2), + std::make_pair("VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR", 1ULL << 3), + std::make_pair("VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR", 1ULL << 4), + std::make_pair("VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR", 1ULL << 5), + std::make_pair("VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR", 1ULL << 6), + std::make_pair("VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR", 1ULL << 7), + std::make_pair("VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR", 1ULL << 8), + std::make_pair("VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR", 1ULL << 9), + std::make_pair("VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR", 1ULL << 10), + std::make_pair("VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR", 1ULL << 11), + std::make_pair("VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR", 1ULL << 12), + std::make_pair("VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT", 1ULL << 13), + std::make_pair("VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR", 1ULL << 14), + std::make_pair("VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR", 1ULL << 15), + std::make_pair("VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR", 1ULL << 16), + std::make_pair("VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR", 1ULL << 17), + std::make_pair("VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR", 1ULL << 18), + std::make_pair("VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR", 1ULL << 19), + std::make_pair("VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR", 1ULL << 20), + std::make_pair("VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR", 1ULL << 21), + std::make_pair("VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR", 1ULL << 22), + std::make_pair("VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR", 1ULL << 23), + std::make_pair("VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR", 1ULL << 31), + std::make_pair("VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR", 1ULL << 32), + std::make_pair("VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR", 1ULL << 33), + std::make_pair("VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR", 1ULL << 25), + std::make_pair("VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR", 1ULL << 26), + std::make_pair("VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR", 1ULL << 29), + std::make_pair("VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT", 1ULL << 24), + std::make_pair("VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR", 1ULL << 30), + std::make_pair("VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR", 1ULL << 27), + std::make_pair("VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR", 1ULL << 28), +}; +static void parse_VkFormatFeatureFlagBits2KHR(const char* s, Json::Value& obj, VkFormatFeatureFlagBits2KHR& o) { + std::string _res = obj.asString(); + o = (VkFormatFeatureFlagBits2KHR)VkFormatFeatureFlagBits2KHR_map[std::string(_res)]; +} + +static void parse_VkFormatFeatureFlags2KHR(const char* s, Json::Value& obj, VkFormatFeatureFlags2KHR& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%" SCNd64, &o); + } + else { + o = obj.asUInt(); + } +} + +#ifdef VK_EXT_image_drm_format_modifier +static void parse_VkDrmFormatModifierPropertiesEXT(const char* s, Json::Value& obj, VkDrmFormatModifierPropertiesEXT& o) { + + parse_uint64_t("drmFormatModifier", obj["drmFormatModifier"], (o.drmFormatModifier)); + + parse_uint32_t("drmFormatModifierPlaneCount", obj["drmFormatModifierPlaneCount"], (o.drmFormatModifierPlaneCount)); + + parse_VkFormatFeatureFlags("drmFormatModifierTilingFeatures", obj["drmFormatModifierTilingFeatures"], (o.drmFormatModifierTilingFeatures)); + +} +#endif + +#ifdef VK_EXT_image_drm_format_modifier +static void parse_VkDrmFormatModifierPropertiesListEXT(const char* s, Json::Value& obj, VkDrmFormatModifierPropertiesListEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDrmFormatModifierPropertiesListEXT*)parsePNextChain(obj); + + parse_uint32_t("drmFormatModifierCount", obj["drmFormatModifierCount"], (o.drmFormatModifierCount)); + + (o.pDrmFormatModifierProperties) = (VkDrmFormatModifierPropertiesEXT*)s_globalMem.allocate((o.drmFormatModifierCount), sizeof(VkDrmFormatModifierPropertiesEXT)); + Json::Value& obj_pDrmFormatModifierProperties = obj["pDrmFormatModifierProperties"]; + if (obj_pDrmFormatModifierProperties.size() == 0) (o.pDrmFormatModifierProperties) = nullptr; + else { + for (unsigned int i = 0; i < (o.drmFormatModifierCount); i++) { + parse_VkDrmFormatModifierPropertiesEXT("pDrmFormatModifierProperties", obj_pDrmFormatModifierProperties[i], const_cast((o.pDrmFormatModifierProperties[i]))); + } + } + +} +#endif + +#ifdef VK_EXT_image_drm_format_modifier +static void parse_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const char* s, Json::Value& obj, VkPhysicalDeviceImageDrmFormatModifierInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceImageDrmFormatModifierInfoEXT*)parsePNextChain(obj); + + parse_uint64_t("drmFormatModifier", obj["drmFormatModifier"], (o.drmFormatModifier)); + + parse_VkSharingMode("sharingMode", obj["sharingMode"], (o.sharingMode)); + + parse_uint32_t("queueFamilyIndexCount", obj["queueFamilyIndexCount"], (o.queueFamilyIndexCount)); + + (o.pQueueFamilyIndices) = (uint32_t*)s_globalMem.allocate((o.queueFamilyIndexCount), sizeof(uint32_t)); + Json::Value& obj_pQueueFamilyIndices_arr = obj["pQueueFamilyIndices"]; + for (unsigned int i = 0; i < obj_pQueueFamilyIndices_arr.size(); i++) { + parse_uint32_t("pQueueFamilyIndices", obj_pQueueFamilyIndices_arr[i], const_cast((o.pQueueFamilyIndices[i]))); + } + +} +#endif + +#ifdef VK_EXT_image_drm_format_modifier +static void parse_VkImageDrmFormatModifierListCreateInfoEXT(const char* s, Json::Value& obj, VkImageDrmFormatModifierListCreateInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImageDrmFormatModifierListCreateInfoEXT*)parsePNextChain(obj); + + parse_uint32_t("drmFormatModifierCount", obj["drmFormatModifierCount"], (o.drmFormatModifierCount)); + + (o.pDrmFormatModifiers) = (uint64_t*)s_globalMem.allocate((o.drmFormatModifierCount), sizeof(uint64_t)); + Json::Value& obj_pDrmFormatModifiers_arr = obj["pDrmFormatModifiers"]; + for (unsigned int i = 0; i < obj_pDrmFormatModifiers_arr.size(); i++) { + parse_uint64_t("pDrmFormatModifiers", obj_pDrmFormatModifiers_arr[i], const_cast((o.pDrmFormatModifiers[i]))); + } + +} +#endif + +#ifdef VK_EXT_image_drm_format_modifier +static void parse_VkImageDrmFormatModifierExplicitCreateInfoEXT(const char* s, Json::Value& obj, VkImageDrmFormatModifierExplicitCreateInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImageDrmFormatModifierExplicitCreateInfoEXT*)parsePNextChain(obj); + + parse_uint64_t("drmFormatModifier", obj["drmFormatModifier"], (o.drmFormatModifier)); + + parse_uint32_t("drmFormatModifierPlaneCount", obj["drmFormatModifierPlaneCount"], (o.drmFormatModifierPlaneCount)); + + (o.pPlaneLayouts) = (VkSubresourceLayout*)s_globalMem.allocate((o.drmFormatModifierPlaneCount), sizeof(VkSubresourceLayout)); + Json::Value& obj_pPlaneLayouts = obj["pPlaneLayouts"]; + if (obj_pPlaneLayouts.size() == 0) (o.pPlaneLayouts) = nullptr; + else { + for (unsigned int i = 0; i < (o.drmFormatModifierPlaneCount); i++) { + parse_VkSubresourceLayout("pPlaneLayouts", obj_pPlaneLayouts[i], const_cast((o.pPlaneLayouts[i]))); + } + } + +} +#endif + +#ifdef VK_EXT_image_drm_format_modifier +static void parse_VkImageDrmFormatModifierPropertiesEXT(const char* s, Json::Value& obj, VkImageDrmFormatModifierPropertiesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImageDrmFormatModifierPropertiesEXT*)parsePNextChain(obj); + + parse_uint64_t("drmFormatModifier", obj["drmFormatModifier"], (o.drmFormatModifier)); + +} +#endif + +#ifdef VK_EXT_image_drm_format_modifier +static void parse_VkDrmFormatModifierProperties2EXT(const char* s, Json::Value& obj, VkDrmFormatModifierProperties2EXT& o) { + + parse_uint64_t("drmFormatModifier", obj["drmFormatModifier"], (o.drmFormatModifier)); + + parse_uint32_t("drmFormatModifierPlaneCount", obj["drmFormatModifierPlaneCount"], (o.drmFormatModifierPlaneCount)); + + parse_VkFormatFeatureFlags2KHR("drmFormatModifierTilingFeatures", obj["drmFormatModifierTilingFeatures"], (o.drmFormatModifierTilingFeatures)); + +} +#endif + +#ifdef VK_EXT_image_drm_format_modifier +static void parse_VkDrmFormatModifierPropertiesList2EXT(const char* s, Json::Value& obj, VkDrmFormatModifierPropertiesList2EXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDrmFormatModifierPropertiesList2EXT*)parsePNextChain(obj); + + parse_uint32_t("drmFormatModifierCount", obj["drmFormatModifierCount"], (o.drmFormatModifierCount)); + + (o.pDrmFormatModifierProperties) = (VkDrmFormatModifierProperties2EXT*)s_globalMem.allocate((o.drmFormatModifierCount), sizeof(VkDrmFormatModifierProperties2EXT)); + Json::Value& obj_pDrmFormatModifierProperties = obj["pDrmFormatModifierProperties"]; + if (obj_pDrmFormatModifierProperties.size() == 0) (o.pDrmFormatModifierProperties) = nullptr; + else { + for (unsigned int i = 0; i < (o.drmFormatModifierCount); i++) { + parse_VkDrmFormatModifierProperties2EXT("pDrmFormatModifierProperties", obj_pDrmFormatModifierProperties[i], const_cast((o.pDrmFormatModifierProperties[i]))); + } + } + +} +#endif + +#ifdef VK_EXT_filter_cubic +static void parse_VkPhysicalDeviceImageViewImageFormatInfoEXT(const char* s, Json::Value& obj, VkPhysicalDeviceImageViewImageFormatInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceImageViewImageFormatInfoEXT*)parsePNextChain(obj); + + parse_VkImageViewType("imageViewType", obj["imageViewType"], (o.imageViewType)); + +} +#endif + +#ifdef VK_EXT_filter_cubic +static void parse_VkFilterCubicImageViewImageFormatPropertiesEXT(const char* s, Json::Value& obj, VkFilterCubicImageViewImageFormatPropertiesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkFilterCubicImageViewImageFormatPropertiesEXT*)parsePNextChain(obj); + + parse_VkBool32("filterCubic", obj["filterCubic"], (o.filterCubic)); + + parse_VkBool32("filterCubicMinmax", obj["filterCubicMinmax"], (o.filterCubicMinmax)); + +} +#endif + +#ifdef VK_EXT_global_priority +static std::map VkQueueGlobalPriorityEXT_map = { + std::make_pair("VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT", 128), + std::make_pair("VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT", 256), + std::make_pair("VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT", 512), + std::make_pair("VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT", 1024), +}; +static void parse_VkQueueGlobalPriorityEXT(const char* s, Json::Value& obj, VkQueueGlobalPriorityEXT& o) { + std::string _res = obj.asString(); + o = (VkQueueGlobalPriorityEXT)VkQueueGlobalPriorityEXT_map[std::string(_res)]; +} +#endif + +#ifdef VK_EXT_global_priority +static void parse_VkDeviceQueueGlobalPriorityCreateInfoEXT(const char* s, Json::Value& obj, VkDeviceQueueGlobalPriorityCreateInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkDeviceQueueGlobalPriorityCreateInfoEXT*)parsePNextChain(obj); + + parse_VkQueueGlobalPriorityEXT("globalPriority", obj["globalPriority"], (o.globalPriority)); + +} +#endif + +#ifdef VK_EXT_external_memory_host +static void parse_VkImportMemoryHostPointerInfoEXT(const char* s, Json::Value& obj, VkImportMemoryHostPointerInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkImportMemoryHostPointerInfoEXT*)parsePNextChain(obj); + + parse_VkExternalMemoryHandleTypeFlagBits("handleType", obj["handleType"], (o.handleType)); + + /** Note: Ignoring void* data. **/ + +} +#endif + +#ifdef VK_EXT_external_memory_host +static void parse_VkMemoryHostPointerPropertiesEXT(const char* s, Json::Value& obj, VkMemoryHostPointerPropertiesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkMemoryHostPointerPropertiesEXT*)parsePNextChain(obj); + + parse_uint32_t("memoryTypeBits", obj["memoryTypeBits"], (o.memoryTypeBits)); + +} +#endif + +#ifdef VK_EXT_external_memory_host +static void parse_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceExternalMemoryHostPropertiesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceExternalMemoryHostPropertiesEXT*)parsePNextChain(obj); + + parse_VkDeviceSize("minImportedHostPointerAlignment", obj["minImportedHostPointerAlignment"], (o.minImportedHostPointerAlignment)); + +} +#endif + +#ifdef VK_EXT_calibrated_timestamps +static std::map VkTimeDomainEXT_map = { + std::make_pair("VK_TIME_DOMAIN_DEVICE_EXT", 0), + std::make_pair("VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT", 1), + std::make_pair("VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT", 2), + std::make_pair("VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT", 3), +}; +static void parse_VkTimeDomainEXT(const char* s, Json::Value& obj, VkTimeDomainEXT& o) { + std::string _res = obj.asString(); + o = (VkTimeDomainEXT)VkTimeDomainEXT_map[std::string(_res)]; +} +#endif + +#ifdef VK_EXT_calibrated_timestamps +static void parse_VkCalibratedTimestampInfoEXT(const char* s, Json::Value& obj, VkCalibratedTimestampInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkCalibratedTimestampInfoEXT*)parsePNextChain(obj); + + parse_VkTimeDomainEXT("timeDomain", obj["timeDomain"], (o.timeDomain)); + +} +#endif + +#ifdef VK_EXT_vertex_attribute_divisor +static void parse_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*)parsePNextChain(obj); + + parse_uint32_t("maxVertexAttribDivisor", obj["maxVertexAttribDivisor"], (o.maxVertexAttribDivisor)); + +} +#endif + +#ifdef VK_EXT_vertex_attribute_divisor +static void parse_VkVertexInputBindingDivisorDescriptionEXT(const char* s, Json::Value& obj, VkVertexInputBindingDivisorDescriptionEXT& o) { + + parse_uint32_t("binding", obj["binding"], (o.binding)); + + parse_uint32_t("divisor", obj["divisor"], (o.divisor)); + +} +#endif + +#ifdef VK_EXT_vertex_attribute_divisor +static void parse_VkPipelineVertexInputDivisorStateCreateInfoEXT(const char* s, Json::Value& obj, VkPipelineVertexInputDivisorStateCreateInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineVertexInputDivisorStateCreateInfoEXT*)parsePNextChain(obj); + + parse_uint32_t("vertexBindingDivisorCount", obj["vertexBindingDivisorCount"], (o.vertexBindingDivisorCount)); + + (o.pVertexBindingDivisors) = (VkVertexInputBindingDivisorDescriptionEXT*)s_globalMem.allocate((o.vertexBindingDivisorCount), sizeof(VkVertexInputBindingDivisorDescriptionEXT)); + Json::Value& obj_pVertexBindingDivisors = obj["pVertexBindingDivisors"]; + if (obj_pVertexBindingDivisors.size() == 0) (o.pVertexBindingDivisors) = nullptr; + else { + for (unsigned int i = 0; i < (o.vertexBindingDivisorCount); i++) { + parse_VkVertexInputBindingDivisorDescriptionEXT("pVertexBindingDivisors", obj_pVertexBindingDivisors[i], const_cast((o.pVertexBindingDivisors[i]))); + } + } + +} +#endif + +#ifdef VK_EXT_vertex_attribute_divisor +static void parse_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("vertexAttributeInstanceRateDivisor", obj["vertexAttributeInstanceRateDivisor"], (o.vertexAttributeInstanceRateDivisor)); + + parse_VkBool32("vertexAttributeInstanceRateZeroDivisor", obj["vertexAttributeInstanceRateZeroDivisor"], (o.vertexAttributeInstanceRateZeroDivisor)); + +} +#endif + +#ifdef VK_EXT_pci_bus_info +static void parse_VkPhysicalDevicePCIBusInfoPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDevicePCIBusInfoPropertiesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDevicePCIBusInfoPropertiesEXT*)parsePNextChain(obj); + + parse_uint32_t("pciDomain", obj["pciDomain"], (o.pciDomain)); + + parse_uint32_t("pciBus", obj["pciBus"], (o.pciBus)); + + parse_uint32_t("pciDevice", obj["pciDevice"], (o.pciDevice)); + + parse_uint32_t("pciFunction", obj["pciFunction"], (o.pciFunction)); + +} +#endif + +#ifdef VK_EXT_subgroup_size_control +static void parse_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("subgroupSizeControl", obj["subgroupSizeControl"], (o.subgroupSizeControl)); + + parse_VkBool32("computeFullSubgroups", obj["computeFullSubgroups"], (o.computeFullSubgroups)); + +} +#endif + +#ifdef VK_EXT_subgroup_size_control +static void parse_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceSubgroupSizeControlPropertiesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*)parsePNextChain(obj); + + parse_uint32_t("minSubgroupSize", obj["minSubgroupSize"], (o.minSubgroupSize)); + + parse_uint32_t("maxSubgroupSize", obj["maxSubgroupSize"], (o.maxSubgroupSize)); + + parse_uint32_t("maxComputeWorkgroupSubgroups", obj["maxComputeWorkgroupSubgroups"], (o.maxComputeWorkgroupSubgroups)); + + parse_VkShaderStageFlags("requiredSubgroupSizeStages", obj["requiredSubgroupSizeStages"], (o.requiredSubgroupSizeStages)); + +} +#endif + +#ifdef VK_EXT_subgroup_size_control +static void parse_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(const char* s, Json::Value& obj, VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*)parsePNextChain(obj); + + parse_uint32_t("requiredSubgroupSize", obj["requiredSubgroupSize"], (o.requiredSubgroupSize)); + +} +#endif + +#ifdef VK_EXT_shader_image_atomic_int64 +static void parse_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("shaderImageInt64Atomics", obj["shaderImageInt64Atomics"], (o.shaderImageInt64Atomics)); + + parse_VkBool32("sparseImageInt64Atomics", obj["sparseImageInt64Atomics"], (o.sparseImageInt64Atomics)); + +} +#endif + +#ifdef VK_EXT_memory_budget +static void parse_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceMemoryBudgetPropertiesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceMemoryBudgetPropertiesEXT*)parsePNextChain(obj); + + Json::Value& obj_heapBudget_arr = obj["heapBudget"]; + for (unsigned int i = 0; i < obj_heapBudget_arr.size(); i++) { + parse_VkDeviceSize("heapBudget", obj_heapBudget_arr[i], const_cast((o.heapBudget[i]))); + } + + Json::Value& obj_heapUsage_arr = obj["heapUsage"]; + for (unsigned int i = 0; i < obj_heapUsage_arr.size(); i++) { + parse_VkDeviceSize("heapUsage", obj_heapUsage_arr[i], const_cast((o.heapUsage[i]))); + } + +} +#endif + +#ifdef VK_EXT_validation_features +static std::map VkValidationFeatureEnableEXT_map = { + std::make_pair("VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT", 0), + std::make_pair("VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT", 1), + std::make_pair("VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT", 2), + std::make_pair("VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT", 3), + std::make_pair("VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT", 4), +}; +static void parse_VkValidationFeatureEnableEXT(const char* s, Json::Value& obj, VkValidationFeatureEnableEXT& o) { + std::string _res = obj.asString(); + o = (VkValidationFeatureEnableEXT)VkValidationFeatureEnableEXT_map[std::string(_res)]; +} +#endif + +#ifdef VK_EXT_validation_features +static std::map VkValidationFeatureDisableEXT_map = { + std::make_pair("VK_VALIDATION_FEATURE_DISABLE_ALL_EXT", 0), + std::make_pair("VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT", 1), + std::make_pair("VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT", 2), + std::make_pair("VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT", 3), + std::make_pair("VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT", 4), + std::make_pair("VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT", 5), + std::make_pair("VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT", 6), + std::make_pair("VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT", 7), +}; +static void parse_VkValidationFeatureDisableEXT(const char* s, Json::Value& obj, VkValidationFeatureDisableEXT& o) { + std::string _res = obj.asString(); + o = (VkValidationFeatureDisableEXT)VkValidationFeatureDisableEXT_map[std::string(_res)]; +} +#endif + +#ifdef VK_EXT_validation_features +static void parse_VkValidationFeaturesEXT(const char* s, Json::Value& obj, VkValidationFeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkValidationFeaturesEXT*)parsePNextChain(obj); + + parse_uint32_t("enabledValidationFeatureCount", obj["enabledValidationFeatureCount"], (o.enabledValidationFeatureCount)); + + (o.pEnabledValidationFeatures) = (VkValidationFeatureEnableEXT*)s_globalMem.allocate((o.enabledValidationFeatureCount), sizeof(VkValidationFeatureEnableEXT)); + Json::Value& obj_pEnabledValidationFeatures_arr = obj["pEnabledValidationFeatures"]; + for (unsigned int i = 0; i < obj_pEnabledValidationFeatures_arr.size(); i++) { + parse_VkValidationFeatureEnableEXT("pEnabledValidationFeatures", obj_pEnabledValidationFeatures_arr[i], const_cast((o.pEnabledValidationFeatures[i]))); + } + + parse_uint32_t("disabledValidationFeatureCount", obj["disabledValidationFeatureCount"], (o.disabledValidationFeatureCount)); + + (o.pDisabledValidationFeatures) = (VkValidationFeatureDisableEXT*)s_globalMem.allocate((o.disabledValidationFeatureCount), sizeof(VkValidationFeatureDisableEXT)); + Json::Value& obj_pDisabledValidationFeatures_arr = obj["pDisabledValidationFeatures"]; + for (unsigned int i = 0; i < obj_pDisabledValidationFeatures_arr.size(); i++) { + parse_VkValidationFeatureDisableEXT("pDisabledValidationFeatures", obj_pDisabledValidationFeatures_arr[i], const_cast((o.pDisabledValidationFeatures[i]))); + } + +} +#endif + +#ifdef VK_EXT_fragment_shader_interlock +static void parse_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("fragmentShaderSampleInterlock", obj["fragmentShaderSampleInterlock"], (o.fragmentShaderSampleInterlock)); + + parse_VkBool32("fragmentShaderPixelInterlock", obj["fragmentShaderPixelInterlock"], (o.fragmentShaderPixelInterlock)); + + parse_VkBool32("fragmentShaderShadingRateInterlock", obj["fragmentShaderShadingRateInterlock"], (o.fragmentShaderShadingRateInterlock)); + +} +#endif + +#ifdef VK_EXT_ycbcr_image_arrays +static void parse_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("ycbcrImageArrays", obj["ycbcrImageArrays"], (o.ycbcrImageArrays)); + +} +#endif + +#ifdef VK_EXT_headless_surface +static void parse_VkHeadlessSurfaceCreateFlagsEXT(const char* s, Json::Value& obj, VkHeadlessSurfaceCreateFlagsEXT& o) { + if (obj.isString()) { + std::string _res = obj.asString(); + sscanf(_res.c_str(), "%u", &o); + } + else { + o = obj.asUInt(); + } +} +#endif + +#ifdef VK_EXT_headless_surface +static void parse_VkHeadlessSurfaceCreateInfoEXT(const char* s, Json::Value& obj, VkHeadlessSurfaceCreateInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkHeadlessSurfaceCreateInfoEXT*)parsePNextChain(obj); + + parse_VkHeadlessSurfaceCreateFlagsEXT("flags", obj["flags"], (o.flags)); + +} +#endif + +#ifdef VK_EXT_line_rasterization +static std::map VkLineRasterizationModeEXT_map = { + std::make_pair("VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT", 0), + std::make_pair("VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT", 1), + std::make_pair("VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT", 2), + std::make_pair("VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT", 3), +}; +static void parse_VkLineRasterizationModeEXT(const char* s, Json::Value& obj, VkLineRasterizationModeEXT& o) { + std::string _res = obj.asString(); + o = (VkLineRasterizationModeEXT)VkLineRasterizationModeEXT_map[std::string(_res)]; +} +#endif + +#ifdef VK_EXT_line_rasterization +static void parse_VkPhysicalDeviceLineRasterizationFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceLineRasterizationFeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceLineRasterizationFeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("rectangularLines", obj["rectangularLines"], (o.rectangularLines)); + + parse_VkBool32("bresenhamLines", obj["bresenhamLines"], (o.bresenhamLines)); + + parse_VkBool32("smoothLines", obj["smoothLines"], (o.smoothLines)); + + parse_VkBool32("stippledRectangularLines", obj["stippledRectangularLines"], (o.stippledRectangularLines)); + + parse_VkBool32("stippledBresenhamLines", obj["stippledBresenhamLines"], (o.stippledBresenhamLines)); + + parse_VkBool32("stippledSmoothLines", obj["stippledSmoothLines"], (o.stippledSmoothLines)); + +} +#endif + +#ifdef VK_EXT_line_rasterization +static void parse_VkPhysicalDeviceLineRasterizationPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceLineRasterizationPropertiesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceLineRasterizationPropertiesEXT*)parsePNextChain(obj); + + parse_uint32_t("lineSubPixelPrecisionBits", obj["lineSubPixelPrecisionBits"], (o.lineSubPixelPrecisionBits)); + +} +#endif + +#ifdef VK_EXT_line_rasterization +static void parse_VkPipelineRasterizationLineStateCreateInfoEXT(const char* s, Json::Value& obj, VkPipelineRasterizationLineStateCreateInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineRasterizationLineStateCreateInfoEXT*)parsePNextChain(obj); + + parse_VkLineRasterizationModeEXT("lineRasterizationMode", obj["lineRasterizationMode"], (o.lineRasterizationMode)); + + parse_VkBool32("stippledLineEnable", obj["stippledLineEnable"], (o.stippledLineEnable)); + + parse_uint32_t("lineStippleFactor", obj["lineStippleFactor"], (o.lineStippleFactor)); + + parse_uint16_t("lineStipplePattern", obj["lineStipplePattern"], (o.lineStipplePattern)); + +} +#endif + +#ifdef VK_EXT_shader_atomic_float +static void parse_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("shaderBufferFloat32Atomics", obj["shaderBufferFloat32Atomics"], (o.shaderBufferFloat32Atomics)); + + parse_VkBool32("shaderBufferFloat32AtomicAdd", obj["shaderBufferFloat32AtomicAdd"], (o.shaderBufferFloat32AtomicAdd)); + + parse_VkBool32("shaderBufferFloat64Atomics", obj["shaderBufferFloat64Atomics"], (o.shaderBufferFloat64Atomics)); + + parse_VkBool32("shaderBufferFloat64AtomicAdd", obj["shaderBufferFloat64AtomicAdd"], (o.shaderBufferFloat64AtomicAdd)); + + parse_VkBool32("shaderSharedFloat32Atomics", obj["shaderSharedFloat32Atomics"], (o.shaderSharedFloat32Atomics)); + + parse_VkBool32("shaderSharedFloat32AtomicAdd", obj["shaderSharedFloat32AtomicAdd"], (o.shaderSharedFloat32AtomicAdd)); + + parse_VkBool32("shaderSharedFloat64Atomics", obj["shaderSharedFloat64Atomics"], (o.shaderSharedFloat64Atomics)); + + parse_VkBool32("shaderSharedFloat64AtomicAdd", obj["shaderSharedFloat64AtomicAdd"], (o.shaderSharedFloat64AtomicAdd)); + + parse_VkBool32("shaderImageFloat32Atomics", obj["shaderImageFloat32Atomics"], (o.shaderImageFloat32Atomics)); + + parse_VkBool32("shaderImageFloat32AtomicAdd", obj["shaderImageFloat32AtomicAdd"], (o.shaderImageFloat32AtomicAdd)); + + parse_VkBool32("sparseImageFloat32Atomics", obj["sparseImageFloat32Atomics"], (o.sparseImageFloat32Atomics)); + + parse_VkBool32("sparseImageFloat32AtomicAdd", obj["sparseImageFloat32AtomicAdd"], (o.sparseImageFloat32AtomicAdd)); + +} +#endif + +#ifdef VK_EXT_index_type_uint8 +static void parse_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceIndexTypeUint8FeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceIndexTypeUint8FeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("indexTypeUint8", obj["indexTypeUint8"], (o.indexTypeUint8)); + +} +#endif + +#ifdef VK_EXT_extended_dynamic_state +static void parse_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("extendedDynamicState", obj["extendedDynamicState"], (o.extendedDynamicState)); + +} +#endif + +#ifdef VK_EXT_shader_demote_to_helper_invocation +static void parse_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("shaderDemoteToHelperInvocation", obj["shaderDemoteToHelperInvocation"], (o.shaderDemoteToHelperInvocation)); + +} +#endif + +#ifdef VK_EXT_texel_buffer_alignment +static void parse_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("texelBufferAlignment", obj["texelBufferAlignment"], (o.texelBufferAlignment)); + +} +#endif + +#ifdef VK_EXT_texel_buffer_alignment +static void parse_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*)parsePNextChain(obj); + + parse_VkDeviceSize("storageTexelBufferOffsetAlignmentBytes", obj["storageTexelBufferOffsetAlignmentBytes"], (o.storageTexelBufferOffsetAlignmentBytes)); + + parse_VkBool32("storageTexelBufferOffsetSingleTexelAlignment", obj["storageTexelBufferOffsetSingleTexelAlignment"], (o.storageTexelBufferOffsetSingleTexelAlignment)); + + parse_VkDeviceSize("uniformTexelBufferOffsetAlignmentBytes", obj["uniformTexelBufferOffsetAlignmentBytes"], (o.uniformTexelBufferOffsetAlignmentBytes)); + + parse_VkBool32("uniformTexelBufferOffsetSingleTexelAlignment", obj["uniformTexelBufferOffsetSingleTexelAlignment"], (o.uniformTexelBufferOffsetSingleTexelAlignment)); + +} +#endif + +#ifdef VK_EXT_robustness2 +static void parse_VkPhysicalDeviceRobustness2FeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceRobustness2FeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceRobustness2FeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("robustBufferAccess2", obj["robustBufferAccess2"], (o.robustBufferAccess2)); + + parse_VkBool32("robustImageAccess2", obj["robustImageAccess2"], (o.robustImageAccess2)); + + parse_VkBool32("nullDescriptor", obj["nullDescriptor"], (o.nullDescriptor)); + +} +#endif + +#ifdef VK_EXT_robustness2 +static void parse_VkPhysicalDeviceRobustness2PropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceRobustness2PropertiesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceRobustness2PropertiesEXT*)parsePNextChain(obj); + + parse_VkDeviceSize("robustStorageBufferAccessSizeAlignment", obj["robustStorageBufferAccessSizeAlignment"], (o.robustStorageBufferAccessSizeAlignment)); + + parse_VkDeviceSize("robustUniformBufferAccessSizeAlignment", obj["robustUniformBufferAccessSizeAlignment"], (o.robustUniformBufferAccessSizeAlignment)); + +} +#endif + +#ifdef VK_EXT_custom_border_color +static void parse_VkSamplerCustomBorderColorCreateInfoEXT(const char* s, Json::Value& obj, VkSamplerCustomBorderColorCreateInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkSamplerCustomBorderColorCreateInfoEXT*)parsePNextChain(obj); + + parse_VkClearColorValue("customBorderColor", obj["customBorderColor"], (o.customBorderColor)); + + parse_VkFormat("format", obj["format"], (o.format)); + +} +#endif + +#ifdef VK_EXT_custom_border_color +static void parse_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceCustomBorderColorPropertiesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceCustomBorderColorPropertiesEXT*)parsePNextChain(obj); + + parse_uint32_t("maxCustomBorderColorSamplers", obj["maxCustomBorderColorSamplers"], (o.maxCustomBorderColorSamplers)); + +} +#endif + +#ifdef VK_EXT_custom_border_color +static void parse_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceCustomBorderColorFeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceCustomBorderColorFeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("customBorderColors", obj["customBorderColors"], (o.customBorderColors)); + + parse_VkBool32("customBorderColorWithoutFormat", obj["customBorderColorWithoutFormat"], (o.customBorderColorWithoutFormat)); + +} +#endif + +#ifdef VK_EXT_ycbcr_2plane_444_formats +static void parse_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("ycbcr2plane444Formats", obj["ycbcr2plane444Formats"], (o.ycbcr2plane444Formats)); + +} +#endif + +#ifdef VK_EXT_image_robustness +static void parse_VkPhysicalDeviceImageRobustnessFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceImageRobustnessFeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceImageRobustnessFeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("robustImageAccess", obj["robustImageAccess"], (o.robustImageAccess)); + +} +#endif + +#ifdef VK_EXT_4444_formats +static void parse_VkPhysicalDevice4444FormatsFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDevice4444FormatsFeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDevice4444FormatsFeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("formatA4R4G4B4", obj["formatA4R4G4B4"], (o.formatA4R4G4B4)); + + parse_VkBool32("formatA4B4G4R4", obj["formatA4B4G4R4"], (o.formatA4B4G4R4)); + +} +#endif + +#ifdef VK_EXT_vertex_input_dynamic_state +static void parse_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("vertexInputDynamicState", obj["vertexInputDynamicState"], (o.vertexInputDynamicState)); + +} +#endif + +#ifdef VK_EXT_vertex_input_dynamic_state +static void parse_VkVertexInputBindingDescription2EXT(const char* s, Json::Value& obj, VkVertexInputBindingDescription2EXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkVertexInputBindingDescription2EXT*)parsePNextChain(obj); + + parse_uint32_t("binding", obj["binding"], (o.binding)); + + parse_uint32_t("stride", obj["stride"], (o.stride)); + + parse_VkVertexInputRate("inputRate", obj["inputRate"], (o.inputRate)); + + parse_uint32_t("divisor", obj["divisor"], (o.divisor)); + +} +#endif + +#ifdef VK_EXT_vertex_input_dynamic_state +static void parse_VkVertexInputAttributeDescription2EXT(const char* s, Json::Value& obj, VkVertexInputAttributeDescription2EXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkVertexInputAttributeDescription2EXT*)parsePNextChain(obj); + + parse_uint32_t("location", obj["location"], (o.location)); + + parse_uint32_t("binding", obj["binding"], (o.binding)); + + parse_VkFormat("format", obj["format"], (o.format)); + + parse_uint32_t("offset", obj["offset"], (o.offset)); + +} +#endif + +#ifdef VK_EXT_extended_dynamic_state2 +static void parse_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("extendedDynamicState2", obj["extendedDynamicState2"], (o.extendedDynamicState2)); + + parse_VkBool32("extendedDynamicState2LogicOp", obj["extendedDynamicState2LogicOp"], (o.extendedDynamicState2LogicOp)); + + parse_VkBool32("extendedDynamicState2PatchControlPoints", obj["extendedDynamicState2PatchControlPoints"], (o.extendedDynamicState2PatchControlPoints)); + +} +#endif + +#ifdef VK_EXT_color_write_enable +static void parse_VkPhysicalDeviceColorWriteEnableFeaturesEXT(const char* s, Json::Value& obj, VkPhysicalDeviceColorWriteEnableFeaturesEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPhysicalDeviceColorWriteEnableFeaturesEXT*)parsePNextChain(obj); + + parse_VkBool32("colorWriteEnable", obj["colorWriteEnable"], (o.colorWriteEnable)); + +} +#endif + +#ifdef VK_EXT_color_write_enable +static void parse_VkPipelineColorWriteCreateInfoEXT(const char* s, Json::Value& obj, VkPipelineColorWriteCreateInfoEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkPipelineColorWriteCreateInfoEXT*)parsePNextChain(obj); + + parse_uint32_t("attachmentCount", obj["attachmentCount"], (o.attachmentCount)); + + (o.pColorWriteEnables) = (VkBool32*)s_globalMem.allocate((o.attachmentCount), sizeof(VkBool32)); + Json::Value& obj_pColorWriteEnables_arr = obj["pColorWriteEnables"]; + for (unsigned int i = 0; i < obj_pColorWriteEnables_arr.size(); i++) { + parse_VkBool32("pColorWriteEnables", obj_pColorWriteEnables_arr[i], const_cast((o.pColorWriteEnables[i]))); + } + +} +#endif + +#ifdef VK_EXT_application_parameters +static void parse_VkApplicationParametersEXT(const char* s, Json::Value& obj, VkApplicationParametersEXT& o) { + + parse_VkStructureType("sType", obj["sType"], (o.sType)); + + o.pNext = (VkApplicationParametersEXT*)parsePNextChain(obj); + + parse_uint32_t("vendorID", obj["vendorID"], (o.vendorID)); + + parse_uint32_t("deviceID", obj["deviceID"], (o.deviceID)); + + parse_uint32_t("key", obj["key"], (o.key)); + + parse_uint64_t("value", obj["value"], (o.value)); + +} +#endif + +}//End of namespace vk_json_parser + +#endif // _VULKAN_JSON_PARSER_HPP \ No newline at end of file diff --git a/registry/apiconventions.py b/registry/apiconventions.py new file mode 100644 index 0000000..13e3dd8 --- /dev/null +++ b/registry/apiconventions.py @@ -0,0 +1,11 @@ +#!/usr/bin/python3 -i +# +# Copyright 2021 The Khronos Group Inc. +# SPDX-License-Identifier: Apache-2.0 + +# Generic alias for working group-specific API conventions interface. + +# This import should be changed at the repository / working group level to +# specify the correct API's conventions. + +from vkconventions import VulkanConventions as APIConventions diff --git a/registry/cgenerator.py b/registry/cgenerator.py new file mode 100644 index 0000000..6685f24 --- /dev/null +++ b/registry/cgenerator.py @@ -0,0 +1,420 @@ +#!/usr/bin/python3 -i +# +# Copyright 2013-2021 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 + +import os +import re +from generator import (GeneratorOptions, OutputGenerator, noneStr, + regSortFeatures, write) + + +class CGeneratorOptions(GeneratorOptions): + """CGeneratorOptions - subclass of GeneratorOptions. + + Adds options used by COutputGenerator objects during C language header + generation.""" + + def __init__(self, + prefixText="", + genFuncPointers=True, + protectFile=True, + protectFeature=True, + protectProto=None, + protectProtoStr=None, + apicall='', + apientry='', + apientryp='', + indentFuncProto=True, + indentFuncPointer=False, + alignFuncParam=0, + genEnumBeginEndRange=False, + genAliasMacro=False, + aliasMacro='', + misracstyle=False, + misracppstyle=False, + **kwargs + ): + """Constructor. + Additional parameters beyond parent class: + + - prefixText - list of strings to prefix generated header with + (usually a copyright statement + calling convention macros). + - protectFile - True if multiple inclusion protection should be + generated (based on the filename) around the entire header. + - protectFeature - True if #ifndef..#endif protection should be + generated around a feature interface in the header file. + - genFuncPointers - True if function pointer typedefs should be + generated + - protectProto - If conditional protection should be generated + around prototype declarations, set to either '#ifdef' + to require opt-in (#ifdef protectProtoStr) or '#ifndef' + to require opt-out (#ifndef protectProtoStr). Otherwise + set to None. + - protectProtoStr - #ifdef/#ifndef symbol to use around prototype + declarations, if protectProto is set + - apicall - string to use for the function declaration prefix, + such as APICALL on Windows. + - apientry - string to use for the calling convention macro, + in typedefs, such as APIENTRY. + - apientryp - string to use for the calling convention macro + in function pointer typedefs, such as APIENTRYP. + - indentFuncProto - True if prototype declarations should put each + parameter on a separate line + - indentFuncPointer - True if typedefed function pointers should put each + parameter on a separate line + - alignFuncParam - if nonzero and parameters are being put on a + separate line, align parameter names at the specified column + - genEnumBeginEndRange - True if BEGIN_RANGE / END_RANGE macros should + be generated for enumerated types + - genAliasMacro - True if the OpenXR alias macro should be generated + for aliased types (unclear what other circumstances this is useful) + - aliasMacro - alias macro to inject when genAliasMacro is True + - misracstyle - generate MISRA C-friendly headers + - misracppstyle - generate MISRA C++-friendly headers""" + + GeneratorOptions.__init__(self, **kwargs) + + self.prefixText = prefixText + """list of strings to prefix generated header with (usually a copyright statement + calling convention macros).""" + + self.genFuncPointers = genFuncPointers + """True if function pointer typedefs should be generated""" + + self.protectFile = protectFile + """True if multiple inclusion protection should be generated (based on the filename) around the entire header.""" + + self.protectFeature = protectFeature + """True if #ifndef..#endif protection should be generated around a feature interface in the header file.""" + + self.protectProto = protectProto + """If conditional protection should be generated around prototype declarations, set to either '#ifdef' to require opt-in (#ifdef protectProtoStr) or '#ifndef' to require opt-out (#ifndef protectProtoStr). Otherwise set to None.""" + + self.protectProtoStr = protectProtoStr + """#ifdef/#ifndef symbol to use around prototype declarations, if protectProto is set""" + + self.apicall = apicall + """string to use for the function declaration prefix, such as APICALL on Windows.""" + + self.apientry = apientry + """string to use for the calling convention macro, in typedefs, such as APIENTRY.""" + + self.apientryp = apientryp + """string to use for the calling convention macro in function pointer typedefs, such as APIENTRYP.""" + + self.indentFuncProto = indentFuncProto + """True if prototype declarations should put each parameter on a separate line""" + + self.indentFuncPointer = indentFuncPointer + """True if typedefed function pointers should put each parameter on a separate line""" + + self.alignFuncParam = alignFuncParam + """if nonzero and parameters are being put on a separate line, align parameter names at the specified column""" + + self.genEnumBeginEndRange = genEnumBeginEndRange + """True if BEGIN_RANGE / END_RANGE macros should be generated for enumerated types""" + + self.genAliasMacro = genAliasMacro + """True if the OpenXR alias macro should be generated for aliased types (unclear what other circumstances this is useful)""" + + self.aliasMacro = aliasMacro + """alias macro to inject when genAliasMacro is True""" + + self.misracstyle = misracstyle + """generate MISRA C-friendly headers""" + + self.misracppstyle = misracppstyle + """generate MISRA C++-friendly headers""" + + self.codeGenerator = True + """True if this generator makes compilable code""" + + +class COutputGenerator(OutputGenerator): + """Generates C-language API interfaces.""" + + # This is an ordered list of sections in the header file. + TYPE_SECTIONS = ['include', 'define', 'basetype', 'handle', 'enum', + 'group', 'bitmask', 'funcpointer', 'struct'] + ALL_SECTIONS = TYPE_SECTIONS + ['commandPointer', 'command'] + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + # Internal state - accumulators for different inner block text + self.sections = {section: [] for section in self.ALL_SECTIONS} + self.feature_not_empty = False + self.may_alias = None + + def beginFile(self, genOpts): + OutputGenerator.beginFile(self, genOpts) + # C-specific + # + # Multiple inclusion protection & C++ wrappers. + if genOpts.protectFile and self.genOpts.filename: + headerSym = re.sub(r'\.h', '_h_', + os.path.basename(self.genOpts.filename)).upper() + write('#ifndef', headerSym, file=self.outFile) + write('#define', headerSym, '1', file=self.outFile) + self.newline() + + # User-supplied prefix text, if any (list of strings) + if genOpts.prefixText: + for s in genOpts.prefixText: + write(s, file=self.outFile) + + # C++ extern wrapper - after prefix lines so they can add includes. + self.newline() + write('#ifdef __cplusplus', file=self.outFile) + write('extern "C" {', file=self.outFile) + write('#endif', file=self.outFile) + self.newline() + + def endFile(self): + # C-specific + # Finish C++ wrapper and multiple inclusion protection + self.newline() + write('#ifdef __cplusplus', file=self.outFile) + write('}', file=self.outFile) + write('#endif', file=self.outFile) + if self.genOpts.protectFile and self.genOpts.filename: + self.newline() + write('#endif', file=self.outFile) + # Finish processing in superclass + OutputGenerator.endFile(self) + + def beginFeature(self, interface, emit): + # Start processing in superclass + OutputGenerator.beginFeature(self, interface, emit) + # C-specific + # Accumulate includes, defines, types, enums, function pointer typedefs, + # end function prototypes separately for this feature. They are only + # printed in endFeature(). + self.sections = {section: [] for section in self.ALL_SECTIONS} + self.feature_not_empty = False + + def endFeature(self): + "Actually write the interface to the output file." + # C-specific + if self.emit: + if self.feature_not_empty: + if self.genOpts.conventions.writeFeature(self.featureExtraProtect, self.genOpts.filename): + self.newline() + if self.genOpts.protectFeature: + write('#ifndef', self.featureName, file=self.outFile) + # If type declarations are needed by other features based on + # this one, it may be necessary to suppress the ExtraProtect, + # or move it below the 'for section...' loop. + if self.featureExtraProtect is not None: + write('#ifdef', self.featureExtraProtect, file=self.outFile) + self.newline() + write('#define', self.featureName, '1', file=self.outFile) + for section in self.TYPE_SECTIONS: + contents = self.sections[section] + if contents: + write('\n'.join(contents), file=self.outFile) + if self.genOpts.genFuncPointers and self.sections['commandPointer']: + write('\n'.join(self.sections['commandPointer']), file=self.outFile) + self.newline() + if self.sections['command']: + if self.genOpts.protectProto: + write(self.genOpts.protectProto, + self.genOpts.protectProtoStr, file=self.outFile) + write('\n'.join(self.sections['command']), end='', file=self.outFile) + if self.genOpts.protectProto: + write('#endif', file=self.outFile) + else: + self.newline() + if self.featureExtraProtect is not None: + write('#endif /*', self.featureExtraProtect, '*/', file=self.outFile) + if self.genOpts.protectFeature: + write('#endif /*', self.featureName, '*/', file=self.outFile) + # Finish processing in superclass + OutputGenerator.endFeature(self) + + def appendSection(self, section, text): + "Append a definition to the specified section" + # self.sections[section].append('SECTION: ' + section + '\n') + self.sections[section].append(text) + self.feature_not_empty = True + + def genType(self, typeinfo, name, alias): + "Generate type." + OutputGenerator.genType(self, typeinfo, name, alias) + typeElem = typeinfo.elem + + # Vulkan: + # Determine the category of the type, and the type section to add + # its definition to. + # 'funcpointer' is added to the 'struct' section as a workaround for + # internal issue #877, since structures and function pointer types + # can have cross-dependencies. + category = typeElem.get('category') + if category == 'funcpointer': + section = 'struct' + else: + section = category + + if category in ('struct', 'union'): + # If the type is a struct type, generate it using the + # special-purpose generator. + self.genStruct(typeinfo, name, alias) + else: + # OpenXR: this section was not under 'else:' previously, just fell through + if alias: + # If the type is an alias, just emit a typedef declaration + body = 'typedef ' + alias + ' ' + name + ';\n' + else: + # Replace tags with an APIENTRY-style string + # (from self.genOpts). Copy other text through unchanged. + # If the resulting text is an empty string, do not emit it. + body = noneStr(typeElem.text) + for elem in typeElem: + if elem.tag == 'apientry': + body += self.genOpts.apientry + noneStr(elem.tail) + else: + body += noneStr(elem.text) + noneStr(elem.tail) + if body: + # Add extra newline after multi-line entries. + if '\n' in body[0:-1]: + body += '\n' + self.appendSection(section, body) + + def genProtectString(self, protect_str): + """Generate protection string. + + Protection strings are the strings defining the OS/Platform/Graphics + requirements for a given OpenXR command. When generating the + language header files, we need to make sure the items specific to a + graphics API or OS platform are properly wrapped in #ifs.""" + protect_if_str = '' + protect_end_str = '' + if not protect_str: + return (protect_if_str, protect_end_str) + + if ',' in protect_str: + protect_list = protect_str.split(",") + protect_defs = ('defined(%s)' % d for d in protect_list) + protect_def_str = ' && '.join(protect_defs) + protect_if_str = '#if %s\n' % protect_def_str + protect_end_str = '#endif // %s\n' % protect_def_str + else: + protect_if_str = '#ifdef %s\n' % protect_str + protect_end_str = '#endif // %s\n' % protect_str + + return (protect_if_str, protect_end_str) + + def typeMayAlias(self, typeName): + if not self.may_alias: + # First time we have asked if a type may alias. + # So, populate the set of all names of types that may. + + # Everyone with an explicit mayalias="true" + self.may_alias = set(typeName + for typeName, data in self.registry.typedict.items() + if data.elem.get('mayalias') == 'true') + + # Every type mentioned in some other type's parentstruct attribute. + parent_structs = (otherType.elem.get('parentstruct') + for otherType in self.registry.typedict.values()) + self.may_alias.update(set(x for x in parent_structs + if x is not None)) + return typeName in self.may_alias + + def genStruct(self, typeinfo, typeName, alias): + """Generate struct (e.g. C "struct" type). + + This is a special case of the tag where the contents are + interpreted as a set of tags instead of freeform C + C type declarations. The tags are just like + tags - they are a declaration of a struct or union member. + Only simple member declarations are supported (no nested + structs etc.) + + If alias is not None, then this struct aliases another; just + generate a typedef of that alias.""" + OutputGenerator.genStruct(self, typeinfo, typeName, alias) + + typeElem = typeinfo.elem + + if alias: + body = 'typedef ' + alias + ' ' + typeName + ';\n' + else: + body = '' + (protect_begin, protect_end) = self.genProtectString(typeElem.get('protect')) + if protect_begin: + body += protect_begin + body += 'typedef ' + typeElem.get('category') + + # This is an OpenXR-specific alternative where aliasing refers + # to an inheritance hierarchy of types rather than C-level type + # aliases. + if self.genOpts.genAliasMacro and self.typeMayAlias(typeName): + body += ' ' + self.genOpts.aliasMacro + + body += ' ' + typeName + ' {\n' + + targetLen = self.getMaxCParamTypeLength(typeinfo) + for member in typeElem.findall('.//member'): + body += self.makeCParamDecl(member, targetLen + 4) + body += ';\n' + body += '} ' + typeName + ';\n' + if protect_end: + body += protect_end + + self.appendSection('struct', body) + + def genGroup(self, groupinfo, groupName, alias=None): + """Generate groups (e.g. C "enum" type). + + These are concatenated together with other types. + + If alias is not None, it is the name of another group type + which aliases this type; just generate that alias.""" + OutputGenerator.genGroup(self, groupinfo, groupName, alias) + groupElem = groupinfo.elem + + # After either enumerated type or alias paths, add the declaration + # to the appropriate section for the group being defined. + if groupElem.get('type') == 'bitmask': + section = 'bitmask' + else: + section = 'group' + + if alias: + # If the group name is aliased, just emit a typedef declaration + # for the alias. + body = 'typedef ' + alias + ' ' + groupName + ';\n' + self.appendSection(section, body) + else: + (section, body) = self.buildEnumCDecl(self.genOpts.genEnumBeginEndRange, groupinfo, groupName) + self.appendSection(section, "\n" + body) + + def genEnum(self, enuminfo, name, alias): + """Generate the C declaration for a constant (a single value).""" + + OutputGenerator.genEnum(self, enuminfo, name, alias) + + body = self.buildConstantCDecl(enuminfo, name, alias) + self.appendSection('enum', body) + + def genCmd(self, cmdinfo, name, alias): + "Command generation" + OutputGenerator.genCmd(self, cmdinfo, name, alias) + + # if alias: + # prefix = '// ' + name + ' is an alias of command ' + alias + '\n' + # else: + # prefix = '' + + prefix = '' + decls = self.makeCDecls(cmdinfo.elem) + self.appendSection('command', prefix + decls[0] + '\n') + if self.genOpts.genFuncPointers: + self.appendSection('commandPointer', decls[1]) + + def misracstyle(self): + return self.genOpts.misracstyle; + + def misracppstyle(self): + return self.genOpts.misracppstyle; diff --git a/registry/conventions.py b/registry/conventions.py new file mode 100644 index 0000000..e005131 --- /dev/null +++ b/registry/conventions.py @@ -0,0 +1,358 @@ +#!/usr/bin/python3 -i +# +# Copyright 2013-2021 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 + +# Base class for working-group-specific style conventions, +# used in generation. + +from enum import Enum + +# Type categories that respond "False" to isStructAlwaysValid +# basetype is home to typedefs like ..Bool32 +CATEGORIES_REQUIRING_VALIDATION = set(('handle', + 'enum', + 'bitmask', + 'basetype', + None)) + +# These are basic C types pulled in via openxr_platform_defines.h +TYPES_KNOWN_ALWAYS_VALID = set(('char', + 'float', + 'int8_t', 'uint8_t', + 'int32_t', 'uint32_t', + 'int64_t', 'uint64_t', + 'size_t', + 'uintptr_t', + 'int', + )) + + +class ProseListFormats(Enum): + """A connective, possibly with a quantifier.""" + AND = 0 + EACH_AND = 1 + OR = 2 + ANY_OR = 3 + + @classmethod + def from_string(cls, s): + if s == 'or': + return cls.OR + if s == 'and': + return cls.AND + return None + + @property + def connective(self): + if self in (ProseListFormats.OR, ProseListFormats.ANY_OR): + return 'or' + return 'and' + + def quantifier(self, n): + """Return the desired quantifier for a list of a given length.""" + if self == ProseListFormats.ANY_OR: + if n > 1: + return 'any of ' + elif self == ProseListFormats.EACH_AND: + if n > 2: + return 'each of ' + if n == 2: + return 'both of ' + return '' + + +class ConventionsBase: + """WG-specific conventions.""" + + def __init__(self): + self._command_prefix = None + self._type_prefix = None + + def formatExtension(self, name): + """Mark up an extension name as a link the spec.""" + return '`apiext:{}`'.format(name) + + @property + def null(self): + """Preferred spelling of NULL.""" + raise NotImplementedError + + def makeProseList(self, elements, fmt=ProseListFormats.AND, with_verb=False, *args, **kwargs): + """Make a (comma-separated) list for use in prose. + + Adds a connective (by default, 'and') + before the last element if there are more than 1. + + Adds the right one of "is" or "are" to the end if with_verb is true. + + Optionally adds a quantifier (like 'any') before a list of 2 or more, + if specified by fmt. + + Override with a different method or different call to + _implMakeProseList if you want to add a comma for two elements, + or not use a serial comma. + """ + return self._implMakeProseList(elements, fmt, with_verb, *args, **kwargs) + + @property + def struct_macro(self): + """Get the appropriate format macro for a structure. + + May override. + """ + return 'slink:' + + @property + def external_macro(self): + """Get the appropriate format macro for an external type like uint32_t. + + May override. + """ + return 'code:' + + def makeStructName(self, name): + """Prepend the appropriate format macro for a structure to a structure type name. + + Uses struct_macro, so just override that if you want to change behavior. + """ + return self.struct_macro + name + + def makeExternalTypeName(self, name): + """Prepend the appropriate format macro for an external type like uint32_t to a type name. + + Uses external_macro, so just override that if you want to change behavior. + """ + return self.external_macro + name + + def _implMakeProseList(self, elements, fmt, with_verb, comma_for_two_elts=False, serial_comma=True): + """Internal-use implementation to make a (comma-separated) list for use in prose. + + Adds a connective (by default, 'and') + before the last element if there are more than 1, + and only includes commas if there are more than 2 + (if comma_for_two_elts is False). + + Adds the right one of "is" or "are" to the end if with_verb is true. + + Optionally adds a quantifier (like 'any') before a list of 2 or more, + if specified by fmt. + + Do not edit these defaults, override self.makeProseList(). + """ + assert(serial_comma) # did not implement what we did not need + if isinstance(fmt, str): + fmt = ProseListFormats.from_string(fmt) + + my_elts = list(elements) + if len(my_elts) > 1: + my_elts[-1] = '{} {}'.format(fmt.connective, my_elts[-1]) + + if not comma_for_two_elts and len(my_elts) <= 2: + prose = ' '.join(my_elts) + else: + prose = ', '.join(my_elts) + + quantifier = fmt.quantifier(len(my_elts)) + + parts = [quantifier, prose] + + if with_verb: + if len(my_elts) > 1: + parts.append(' are') + else: + parts.append(' is') + return ''.join(parts) + + @property + def file_suffix(self): + """Return suffix of generated Asciidoctor files""" + raise NotImplementedError + + def api_name(self, spectype=None): + """Return API or specification name for citations in ref pages. + + spectype is the spec this refpage is for. + 'api' (the default value) is the main API Specification. + If an unrecognized spectype is given, returns None. + + Must implement.""" + raise NotImplementedError + + def should_insert_may_alias_macro(self, genOpts): + """Return true if we should insert a "may alias" macro in this file. + + Only used by OpenXR right now.""" + return False + + @property + def command_prefix(self): + """Return the expected prefix of commands/functions. + + Implemented in terms of api_prefix.""" + if not self._command_prefix: + self._command_prefix = self.api_prefix[:].replace('_', '').lower() + return self._command_prefix + + @property + def type_prefix(self): + """Return the expected prefix of type names. + + Implemented in terms of command_prefix (and in turn, api_prefix).""" + if not self._type_prefix: + self._type_prefix = ''.join( + (self.command_prefix[0:1].upper(), self.command_prefix[1:])) + return self._type_prefix + + @property + def api_prefix(self): + """Return API token prefix. + + Typically two uppercase letters followed by an underscore. + + Must implement.""" + raise NotImplementedError + + @property + def api_version_prefix(self): + """Return API core version token prefix. + + Implemented in terms of api_prefix. + + May override.""" + return self.api_prefix + 'VERSION_' + + @property + def KHR_prefix(self): + """Return extension name prefix for KHR extensions. + + Implemented in terms of api_prefix. + + May override.""" + return self.api_prefix + 'KHR_' + + @property + def EXT_prefix(self): + """Return extension name prefix for EXT extensions. + + Implemented in terms of api_prefix. + + May override.""" + return self.api_prefix + 'EXT_' + + def writeFeature(self, featureExtraProtect, filename): + """Return True if OutputGenerator.endFeature should write this feature. + + Defaults to always True. + Used in COutputGenerator. + + May override.""" + return True + + def requires_error_validation(self, return_type): + """Return True if the return_type element is an API result code + requiring error validation. + + Defaults to always False. + + May override.""" + return False + + @property + def required_errors(self): + """Return a list of required error codes for validation. + + Defaults to an empty list. + + May override.""" + return [] + + def is_voidpointer_alias(self, tag, text, tail): + """Return True if the declaration components (tag,text,tail) of an + element represents a void * type. + + Defaults to a reasonable implementation. + + May override.""" + return tag == 'type' and text == 'void' and tail.startswith('*') + + def make_voidpointer_alias(self, tail): + """Reformat a void * declaration to include the API alias macro. + + Defaults to a no-op. + + Must override if you actually want to use this feature in your project.""" + return tail + + def category_requires_validation(self, category): + """Return True if the given type 'category' always requires validation. + + Defaults to a reasonable implementation. + + May override.""" + return category in CATEGORIES_REQUIRING_VALIDATION + + def type_always_valid(self, typename): + """Return True if the given type name is always valid (never requires validation). + + This is for things like integers. + + Defaults to a reasonable implementation. + + May override.""" + return typename in TYPES_KNOWN_ALWAYS_VALID + + @property + def should_skip_checking_codes(self): + """Return True if more than the basic validation of return codes should + be skipped for a command.""" + + return False + + @property + def generate_index_terms(self): + """Return True if asiidoctor index terms should be generated as part + of an API interface from the docgenerator.""" + + return False + + @property + def generate_enum_table(self): + """Return True if asciidoctor tables describing enumerants in a + group should be generated as part of group generation.""" + return False + + @property + def generate_max_enum_in_docs(self): + """Return True if MAX_ENUM tokens should be generated in + documentation includes.""" + return False + + + def extension_include_string(self, ext): + """Return format string for include:: line for an extension appendix + file. ext is an object with the following members: + - name - extension string string + - vendor - vendor portion of name + - barename - remainder of name + + Must implement.""" + raise NotImplementedError + + @property + def refpage_generated_include_path(self): + """Return path relative to the generated reference pages, to the + generated API include files. + + Must implement.""" + raise NotImplementedError + + def valid_flag_bit(self, bitpos): + """Return True if bitpos is an allowed numeric bit position for + an API flag. + + Behavior depends on the data type used for flags (which may be 32 + or 64 bits), and may depend on assumptions about compiler + handling of sign bits in enumerated types, as well.""" + return True diff --git a/registry/generator.py b/registry/generator.py new file mode 100644 index 0000000..0c2a408 --- /dev/null +++ b/registry/generator.py @@ -0,0 +1,1222 @@ +#!/usr/bin/python3 -i +# +# Copyright 2013-2021 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 +"""Base class for source/header/doc generators, as well as some utility functions.""" + +from __future__ import unicode_literals + +import io +import os +import pdb +import re +import shutil +import sys +import tempfile +try: + from pathlib import Path +except ImportError: + from pathlib2 import Path + +from spec_tools.util import getElemName, getElemType + + +def write(*args, **kwargs): + file = kwargs.pop('file', sys.stdout) + end = kwargs.pop('end', '\n') + file.write(' '.join(str(arg) for arg in args)) + file.write(end) + + +def noneStr(s): + """Return string argument, or "" if argument is None. + + Used in converting etree Elements into text. + s - string to convert""" + if s: + return s + return "" + + +def enquote(s): + """Return string argument with surrounding quotes, + for serialization into Python code.""" + if s: + if isinstance(s, str): + return "'{}'".format(s) + else: + return s + return None + + +def regSortCategoryKey(feature): + """Sort key for regSortFeatures. + Sorts by category of the feature name string: + + - Core API features (those defined with a `` tag) + - (sort VKSC after VK) + - ARB/KHR/OES (Khronos extensions) + - other (EXT/vendor extensions)""" + + if feature.elem.tag == 'feature': + if feature.name.startswith('VKSC'): + return 0.5 + return 0 + if (feature.category == 'ARB' + or feature.category == 'KHR' + or feature.category == 'OES'): + return 1 + + return 2 + + +def regSortOrderKey(feature): + """Sort key for regSortFeatures - key is the sortorder attribute.""" + + # print("regSortOrderKey {} -> {}".format(feature.name, feature.sortorder)) + return feature.sortorder + + +def regSortFeatureVersionKey(feature): + """Sort key for regSortFeatures - key is the feature version. + `` elements all have version number 0.""" + + return float(feature.versionNumber) + + +def regSortExtensionNumberKey(feature): + """Sort key for regSortFeatures - key is the extension number. + `` elements all have extension number 0.""" + + return int(feature.number) + + +def regSortFeatures(featureList): + """Default sort procedure for features. + + - Sorts by explicit sort order (default 0) relative to other features + - then by feature category ('feature' or 'extension'), + - then by version number (for features) + - then by extension number (for extensions)""" + featureList.sort(key=regSortExtensionNumberKey) + featureList.sort(key=regSortFeatureVersionKey) + featureList.sort(key=regSortCategoryKey) + featureList.sort(key=regSortOrderKey) + + +class GeneratorOptions: + """Base class for options used during header/documentation production. + + These options are target language independent, and used by + Registry.apiGen() and by base OutputGenerator objects.""" + + def __init__(self, + conventions=None, + filename=None, + directory='.', + genpath=None, + apiname=None, + profile=None, + versions='.*', + emitversions='.*', + defaultExtensions=None, + addExtensions=None, + removeExtensions=None, + emitExtensions=None, + emitSpirv=None, + emitFormats=None, + reparentEnums=True, + sortProcedure=regSortFeatures, + requireCommandAliases=False, + ): + """Constructor. + + Arguments: + + - conventions - may be mandatory for some generators: + an object that implements ConventionsBase + - filename - basename of file to generate, or None to write to stdout. + - directory - directory in which to generate files + - genpath - path to previously generated files, such as api.py + - apiname - string matching `` 'apiname' attribute, e.g. 'gl'. + - profile - string specifying API profile , e.g. 'core', or None. + - versions - regex matching API versions to process interfaces for. + Normally `'.*'` or `'[0-9][.][0-9]'` to match all defined versions. + - emitversions - regex matching API versions to actually emit + interfaces for (though all requested versions are considered + when deciding which interfaces to generate). For GL 4.3 glext.h, + this might be `'1[.][2-5]|[2-4][.][0-9]'`. + - defaultExtensions - If not None, a string which must in its + entirety match the pattern in the "supported" attribute of + the ``. Defaults to None. Usually the same as apiname. + - addExtensions - regex matching names of additional extensions + to include. Defaults to None. + - removeExtensions - regex matching names of extensions to + remove (after defaultExtensions and addExtensions). Defaults + to None. + - emitExtensions - regex matching names of extensions to actually emit + interfaces for (though all requested versions are considered when + deciding which interfaces to generate). + to None. + - emitSpirv - regex matching names of extensions and capabilities + to actually emit interfaces for. + - emitFormats - regex matching names of formats to actually emit + interfaces for. + - reparentEnums - move elements which extend an enumerated + type from or elements to the target + element. This is required for almost all purposes, but the + InterfaceGenerator relies on the list of interfaces in the + or being complete. Defaults to True. + - sortProcedure - takes a list of FeatureInfo objects and sorts + them in place to a preferred order in the generated output. + Default is core API versions, ARB/KHR/OES extensions, all other + extensions, by core API version number or extension number in each + group. + + The regex patterns can be None or empty, in which case they match + nothing.""" + self.conventions = conventions + """may be mandatory for some generators: + an object that implements ConventionsBase""" + + self.filename = filename + "basename of file to generate, or None to write to stdout." + + self.genpath = genpath + """path to previously generated files, such as api.py""" + + self.directory = directory + "directory in which to generate filename" + + self.apiname = apiname + "string matching `` 'apiname' attribute, e.g. 'gl'." + + self.profile = profile + "string specifying API profile , e.g. 'core', or None." + + self.versions = self.emptyRegex(versions) + """regex matching API versions to process interfaces for. + Normally `'.*'` or `'[0-9][.][0-9]'` to match all defined versions.""" + + self.emitversions = self.emptyRegex(emitversions) + """regex matching API versions to actually emit + interfaces for (though all requested versions are considered + when deciding which interfaces to generate). For GL 4.3 glext.h, + this might be `'1[.][2-5]|[2-4][.][0-9]'`.""" + + self.defaultExtensions = defaultExtensions + """If not None, a string which must in its + entirety match the pattern in the "supported" attribute of + the ``. Defaults to None. Usually the same as apiname.""" + + self.addExtensions = self.emptyRegex(addExtensions) + """regex matching names of additional extensions + to include. Defaults to None.""" + + self.removeExtensions = self.emptyRegex(removeExtensions) + """regex matching names of extensions to + remove (after defaultExtensions and addExtensions). Defaults + to None.""" + + self.emitExtensions = self.emptyRegex(emitExtensions) + """regex matching names of extensions to actually emit + interfaces for (though all requested versions are considered when + deciding which interfaces to generate).""" + + self.emitSpirv = self.emptyRegex(emitSpirv) + """regex matching names of extensions and capabilities + to actually emit interfaces for.""" + + self.emitFormats = self.emptyRegex(emitFormats) + """regex matching names of formats + to actually emit interfaces for.""" + + self.reparentEnums = reparentEnums + """boolean specifying whether to remove elements from + or when extending an type.""" + + self.sortProcedure = sortProcedure + """takes a list of FeatureInfo objects and sorts + them in place to a preferred order in the generated output. + Default is core API versions, ARB/KHR/OES extensions, all + other extensions, alphabetically within each group.""" + + self.codeGenerator = False + """True if this generator makes compilable code""" + + self.requireCommandAliases = requireCommandAliases + """True if alias= attributes of tags are transitively + required.""" + + def emptyRegex(self, pat): + """Substitute a regular expression which matches no version + or extension names for None or the empty string.""" + if not pat: + return '_nomatch_^' + + return pat + + +class OutputGenerator: + """Generate specified API interfaces in a specific style, such as a C header. + + Base class for generating API interfaces. + Manages basic logic, logging, and output file control. + Derived classes actually generate formatted output. + """ + + # categoryToPath - map XML 'category' to include file directory name + categoryToPath = { + 'bitmask': 'flags', + 'enum': 'enums', + 'funcpointer': 'funcpointers', + 'handle': 'handles', + 'define': 'defines', + 'basetype': 'basetypes', + } + + def breakName(self, name, msg): + """Break into debugger if this is a special name""" + + # List of string names to break on + bad = ( + ) + + if name in bad and True: + print('breakName {}: {}'.format(name, msg)) + pdb.set_trace() + + def __init__(self, errFile=sys.stderr, warnFile=sys.stderr, diagFile=sys.stdout): + """Constructor + + - errFile, warnFile, diagFile - file handles to write errors, + warnings, diagnostics to. May be None to not write.""" + self.outFile = None + self.errFile = errFile + self.warnFile = warnFile + self.diagFile = diagFile + # Internal state + self.featureName = None + self.genOpts = None + self.registry = None + self.featureDictionary = {} + # Used for extension enum value generation + self.extBase = 1000000000 + self.extBlockSize = 1000 + self.madeDirs = {} + + # API dictionary, which may be loaded by the beginFile method of + # derived generators. + self.apidict = None + + def logMsg(self, level, *args): + """Write a message of different categories to different + destinations. + + - `level` + - 'diag' (diagnostic, voluminous) + - 'warn' (warning) + - 'error' (fatal error - raises exception after logging) + + - `*args` - print()-style arguments to direct to corresponding log""" + if level == 'error': + strfile = io.StringIO() + write('ERROR:', *args, file=strfile) + if self.errFile is not None: + write(strfile.getvalue(), file=self.errFile) + raise UserWarning(strfile.getvalue()) + elif level == 'warn': + if self.warnFile is not None: + write('WARNING:', *args, file=self.warnFile) + elif level == 'diag': + if self.diagFile is not None: + write('DIAG:', *args, file=self.diagFile) + else: + raise UserWarning( + '*** FATAL ERROR in Generator.logMsg: unknown level:' + level) + + def enumToValue(self, elem, needsNum, bitwidth = 32, forceSuffix = False): + """Parse and convert an `` tag into a value. + + Returns a list: + + - first element - integer representation of the value, or None + if needsNum is False. The value must be a legal number + if needsNum is True. + - second element - string representation of the value + + There are several possible representations of values. + + - A 'value' attribute simply contains the value. + - A 'bitpos' attribute defines a value by specifying the bit + position which is set in that value. + - An 'offset','extbase','extends' triplet specifies a value + as an offset to a base value defined by the specified + 'extbase' extension name, which is then cast to the + typename specified by 'extends'. This requires probing + the registry database, and imbeds knowledge of the + API extension enum scheme in this function. + - An 'alias' attribute contains the name of another enum + which this is an alias of. The other enum must be + declared first when emitting this enum.""" + name = elem.get('name') + numVal = None + if 'value' in elem.keys(): + value = elem.get('value') + # print('About to translate value =', value, 'type =', type(value)) + if needsNum: + numVal = int(value, 0) + # If there is a non-integer, numeric 'type' attribute (e.g. 'u' or + # 'ull'), append it to the string value. + # t = enuminfo.elem.get('type') + # if t is not None and t != '' and t != 'i' and t != 's': + # value += enuminfo.type + if forceSuffix: + if bitwidth == 64: + value = value + 'ULL' + else: + value = value + 'U' + self.logMsg('diag', 'Enum', name, '-> value [', numVal, ',', value, ']') + return [numVal, value] + if 'bitpos' in elem.keys(): + value = elem.get('bitpos') + bitpos = int(value, 0) + numVal = 1 << bitpos + value = '0x%08x' % numVal + if bitwidth == 64: + value = value + 'ULL' + elif forceSuffix: + value = value + 'U' + self.logMsg('diag', 'Enum', name, '-> bitpos [', numVal, ',', value, ']') + return [numVal, value] + if 'offset' in elem.keys(): + # Obtain values in the mapping from the attributes + enumNegative = False + offset = int(elem.get('offset'), 0) + extnumber = int(elem.get('extnumber'), 0) + extends = elem.get('extends') + if 'dir' in elem.keys(): + enumNegative = True + self.logMsg('diag', 'Enum', name, 'offset =', offset, + 'extnumber =', extnumber, 'extends =', extends, + 'enumNegative =', enumNegative) + # Now determine the actual enumerant value, as defined + # in the "Layers and Extensions" appendix of the spec. + numVal = self.extBase + (extnumber - 1) * self.extBlockSize + offset + if enumNegative: + numVal *= -1 + value = '%d' % numVal + # More logic needed! + self.logMsg('diag', 'Enum', name, '-> offset [', numVal, ',', value, ']') + return [numVal, value] + if 'alias' in elem.keys(): + return [None, elem.get('alias')] + return [None, None] + + def checkDuplicateEnums(self, enums): + """Check enumerated values for duplicates. + + - enums - list of `` Elements + + returns the list with duplicates stripped""" + # Dictionaries indexed by name and numeric value. + # Entries are [ Element, numVal, strVal ] matching name or value + + nameMap = {} + valueMap = {} + + stripped = [] + for elem in enums: + name = elem.get('name') + (numVal, strVal) = self.enumToValue(elem, True) + + if name in nameMap: + # Duplicate name found; check values + (name2, numVal2, strVal2) = nameMap[name] + + # Duplicate enum values for the same name are benign. This + # happens when defining the same enum conditionally in + # several extension blocks. + if (strVal2 == strVal or (numVal is not None + and numVal == numVal2)): + True + # self.logMsg('info', 'checkDuplicateEnums: Duplicate enum (' + name + + # ') found with the same value:' + strVal) + else: + self.logMsg('warn', 'checkDuplicateEnums: Duplicate enum (' + name + + ') found with different values:' + strVal + + ' and ' + strVal2) + + # Do not add the duplicate to the returned list + continue + elif numVal in valueMap: + # Duplicate value found (such as an alias); report it, but + # still add this enum to the list. + (name2, numVal2, strVal2) = valueMap[numVal] + + msg = 'Two enums found with the same value: {} = {} = {}'.format( + name, name2.get('name'), strVal) + self.logMsg('error', msg) + + # Track this enum to detect followon duplicates + nameMap[name] = [elem, numVal, strVal] + if numVal is not None: + valueMap[numVal] = [elem, numVal, strVal] + + # Add this enum to the list + stripped.append(elem) + + # Return the list + return stripped + + def misracstyle(self): + return False; + + def misracppstyle(self): + return False; + + def buildEnumCDecl(self, expand, groupinfo, groupName): + """Generate the C declaration for an enum""" + groupElem = groupinfo.elem + + # Determine the required bit width for the enum group. + # 32 is the default, which generates C enum types for the values. + bitwidth = 32 + + # If the constFlagBits preference is set, 64 is the default for bitmasks + if self.genOpts.conventions.constFlagBits and groupElem.get('type') == 'bitmask': + bitwidth = 64 + + # Check for an explicitly defined bitwidth, which will override any defaults. + if groupElem.get('bitwidth'): + try: + bitwidth = int(groupElem.get('bitwidth')) + except ValueError as ve: + self.logMsg('error', 'Invalid value for bitwidth attribute (', groupElem.get('bitwidth'), ') for ', groupName, ' - must be an integer value\n') + exit(1) + + usebitmask = False + usedefine = False + + # Bitmask flags can be generated as either "static const uint{32,64}_t" values, + # or as 32-bit C enums. 64-bit types must use uint64_t values. + if groupElem.get('type') == 'bitmask': + if bitwidth > 32 or self.misracppstyle(): + usebitmask = True + if self.misracstyle(): + usedefine = True + + if usedefine or usebitmask: + # Validate the bitwidth and generate values appropriately + if bitwidth > 64: + self.logMsg('error', 'Invalid value for bitwidth attribute (', groupElem.get('bitwidth'), ') for bitmask type ', groupName, ' - must be less than or equal to 64\n') + exit(1) + else: + return self.buildEnumCDecl_BitmaskOrDefine(groupinfo, groupName, bitwidth, usedefine) + else: + # Validate the bitwidth and generate values appropriately + if bitwidth > 32: + self.logMsg('error', 'Invalid value for bitwidth attribute (', groupElem.get('bitwidth'), ') for enum type ', groupName, ' - must be less than or equal to 32\n') + exit(1) + else: + return self.buildEnumCDecl_Enum(expand, groupinfo, groupName) + + def buildEnumCDecl_BitmaskOrDefine(self, groupinfo, groupName, bitwidth, usedefine): + """Generate the C declaration for an "enum" that is actually a + set of flag bits""" + groupElem = groupinfo.elem + flagTypeName = groupElem.get('name') + + # Prefix + body = "// Flag bits for " + flagTypeName + "\n" + + if bitwidth == 64: + body += "typedef VkFlags64 %s;\n" % flagTypeName; + else: + body += "typedef VkFlags %s;\n" % flagTypeName; + + # Maximum allowable value for a flag (unsigned 64-bit integer) + maxValidValue = 2**(64) - 1 + minValidValue = 0 + + # Get a list of nested 'enum' tags. + enums = groupElem.findall('enum') + + # Check for and report duplicates, and return a list with them + # removed. + enums = self.checkDuplicateEnums(enums) + + # Accumulate non-numeric enumerant values separately and append + # them following the numeric values, to allow for aliases. + # NOTE: this does not do a topological sort yet, so aliases of + # aliases can still get in the wrong order. + aliasText = '' + + # Loop over the nested 'enum' tags. + for elem in enums: + # Convert the value to an integer and use that to track min/max. + # Values of form -(number) are accepted but nothing more complex. + # Should catch exceptions here for more complex constructs. Not yet. + (numVal, strVal) = self.enumToValue(elem, True, bitwidth, True) + name = elem.get('name') + + # Range check for the enum value + if numVal is not None and (numVal > maxValidValue or numVal < minValidValue): + self.logMsg('error', 'Allowable range for flag types in C is [', minValidValue, ',', maxValidValue, '], but', name, 'flag has a value outside of this (', strVal, ')\n') + exit(1) + + decl = self.genRequirements(name, mustBeFound = False) + + if self.isEnumRequired(elem): + protect = elem.get('protect') + if protect is not None: + body += '#ifdef {}\n'.format(protect) + + if usedefine: + decl += "#define {} {}\n".format(name, strVal) + elif self.misracppstyle(): + decl += "static constexpr {} {} {{{}}};\n".format(flagTypeName, name, strVal) + else: + # Some C compilers only allow initializing a 'static const' variable with a literal value. + # So initializing an alias from another 'static const' value would fail to compile. + # Work around this by chasing the aliases to get the actual value. + while numVal is None: + alias = self.registry.tree.find("enums/enum[@name='" + strVal + "']") + (numVal, strVal) = self.enumToValue(alias, True, bitwidth, True) + decl += "static const {} {} = {};\n".format(flagTypeName, name, strVal) + + if numVal is not None: + body += decl + else: + aliasText += decl + + if protect is not None: + body += '#endif\n' + + # Now append the non-numeric enumerant values + body += aliasText + + # Postfix + + return ("bitmask", body) + + def buildEnumCDecl_Enum(self, expand, groupinfo, groupName): + """Generate the C declaration for an enumerated type""" + groupElem = groupinfo.elem + + # Break the group name into prefix and suffix portions for range + # enum generation + expandName = re.sub(r'([0-9]+|[a-z_])([A-Z0-9])', r'\1_\2', groupName).upper() + expandPrefix = expandName + expandSuffix = '' + expandSuffixMatch = re.search(r'[A-Z][A-Z]+$', groupName) + if expandSuffixMatch: + expandSuffix = '_' + expandSuffixMatch.group() + # Strip off the suffix from the prefix + expandPrefix = expandName.rsplit(expandSuffix, 1)[0] + + # Prefix + body = ["typedef enum %s {" % groupName] + + # @@ Should use the type="bitmask" attribute instead + isEnum = ('FLAG_BITS' not in expandPrefix) + + # Allowable range for a C enum - which is that of a signed 32-bit integer + maxValidValue = 2**(32 - 1) - 1 + minValidValue = (maxValidValue * -1) - 1 + + + # Get a list of nested 'enum' tags. + enums = groupElem.findall('enum') + + # Check for and report duplicates, and return a list with them + # removed. + enums = self.checkDuplicateEnums(enums) + + # Loop over the nested 'enum' tags. Keep track of the minimum and + # maximum numeric values, if they can be determined; but only for + # core API enumerants, not extension enumerants. This is inferred + # by looking for 'extends' attributes. + minName = None + + # Accumulate non-numeric enumerant values separately and append + # them following the numeric values, to allow for aliases. + # NOTE: this does not do a topological sort yet, so aliases of + # aliases can still get in the wrong order. + aliasText = [] + + for elem in enums: + # Convert the value to an integer and use that to track min/max. + # Values of form -(number) are accepted but nothing more complex. + # Should catch exceptions here for more complex constructs. Not yet. + (numVal, strVal) = self.enumToValue(elem, True) + name = elem.get('name') + + # Extension enumerants are only included if they are required + if self.isEnumRequired(elem): + decl = '' + + protect = elem.get('protect') + if protect is not None: + decl += '#ifdef {}\n'.format(protect) + + # Indent requirements comment, if there is one + requirements = self.genRequirements(name, mustBeFound = False) + if requirements != '': + requirements = ' ' + requirements + decl += requirements + decl += ' {} = {},'.format(name, strVal) + + if protect is not None: + decl += '\n#endif' + + if numVal is not None: + body.append(decl) + else: + aliasText.append(decl) + + # Range check for the enum value + if numVal is not None and (numVal > maxValidValue or numVal < minValidValue): + self.logMsg('error', 'Allowable range for C enum types is [', minValidValue, ',', maxValidValue, '], but', name, 'has a value outside of this (', strVal, ')\n') + exit(1) + + # Do not track min/max for non-numbers (numVal is None) + if isEnum and numVal is not None and elem.get('extends') is None: + if minName is None: + minName = maxName = name + minValue = maxValue = numVal + elif numVal < minValue: + minName = name + minValue = numVal + elif numVal > maxValue: + maxName = name + maxValue = numVal + + # Now append the non-numeric enumerant values + body.extend(aliasText) + + # Generate min/max value tokens - legacy use case. + if isEnum and expand: + body.extend((" {}_BEGIN_RANGE{} = {},".format(expandPrefix, expandSuffix, minName), + " {}_END_RANGE{} = {},".format( + expandPrefix, expandSuffix, maxName), + " {}_RANGE_SIZE{} = ({} - {} + 1),".format(expandPrefix, expandSuffix, maxName, minName))) + + # Generate a range-padding value to ensure the enum is 32 bits, but + # only in code generators, so it does not appear in documentation + if (self.genOpts.codeGenerator or + self.conventions.generate_max_enum_in_docs): + body.append(" {}_MAX_ENUM{} = 0x7FFFFFFF".format( + expandPrefix, expandSuffix)) + + # Postfix + body.append("} %s;" % groupName) + + # Determine appropriate section for this declaration + if groupElem.get('type') == 'bitmask': + section = 'bitmask' + else: + section = 'group' + + return (section, '\n'.join(body)) + + def buildConstantCDecl(self, enuminfo, name, alias): + """Generate the C declaration for a constant (a single + value). + + tags may specify their values in several ways, but are + usually just integers or floating-point numbers.""" + + (_, strVal) = self.enumToValue(enuminfo.elem, False) + + if self.misracppstyle() and enuminfo.elem.get('type') and not alias: + # Generate e.g.: static constexpr uint32_t x = ~static_cast(1U); + # This appeases MISRA "underlying type" rules. + typeStr = enuminfo.elem.get('type'); + invert = '~' in strVal + number = strVal.strip("()~UL") + if typeStr != "float": + number += 'U' + strVal = "~" if invert else "" + strVal += "static_cast<" + typeStr + ">(" + number + ")" + body = 'static constexpr ' + typeStr.ljust(9) + name.ljust(33) + ' {' + strVal + '};' + elif enuminfo.elem.get('type') and not alias: + # Generate e.g.: #define x (~0ULL) + typeStr = enuminfo.elem.get('type'); + invert = '~' in strVal + paren = '(' in strVal + number = strVal.strip("()~UL") + if typeStr != "float": + if typeStr == "uint64_t": + number += 'ULL' + else: + number += 'U' + strVal = "~" if invert else "" + strVal += number + if paren: + strVal = "(" + strVal + ")"; + body = '#define ' + name.ljust(33) + ' ' + strVal; + else: + body = '#define ' + name.ljust(33) + ' ' + strVal + + return body + + def makeDir(self, path): + """Create a directory, if not already done. + + Generally called from derived generators creating hierarchies.""" + self.logMsg('diag', 'OutputGenerator::makeDir(' + path + ')') + if path not in self.madeDirs: + # This can get race conditions with multiple writers, see + # https://stackoverflow.com/questions/273192/ + if not os.path.exists(path): + os.makedirs(path) + self.madeDirs[path] = None + + def beginFile(self, genOpts): + """Start a new interface file + + - genOpts - GeneratorOptions controlling what is generated and how""" + self.genOpts = genOpts + self.should_insert_may_alias_macro = \ + self.genOpts.conventions.should_insert_may_alias_macro(self.genOpts) + + # Try to import the API dictionary, api.py, if it exists. Nothing in + # api.py cannot be extracted directly from the XML, and in the + # future we should do that. + if self.genOpts.genpath is not None: + try: + sys.path.insert(0, self.genOpts.genpath) + import api + self.apidict = api + except ImportError: + self.apidict = None + + self.conventions = genOpts.conventions + + # Open a temporary file for accumulating output. + if self.genOpts.filename is not None: + self.outFile = tempfile.NamedTemporaryFile(mode='w', encoding='utf-8', newline='\n', delete=False) + else: + self.outFile = sys.stdout + + def endFile(self): + if self.errFile: + self.errFile.flush() + if self.warnFile: + self.warnFile.flush() + if self.diagFile: + self.diagFile.flush() + if self.outFile != sys.stdout and self.outFile != sys.stderr: + self.outFile.close() + + # On successfully generating output, move the temporary file to the + # target file. + if self.genOpts.filename is not None: + if sys.platform == 'win32': + directory = Path(self.genOpts.directory) + if not Path.exists(directory): + os.makedirs(directory) + shutil.copy(self.outFile.name, self.genOpts.directory + '/' + self.genOpts.filename) + os.remove(self.outFile.name) + self.genOpts = None + + def beginFeature(self, interface, emit): + """Write interface for a feature and tag generated features as having been done. + + - interface - element for the `` / `` to generate + - emit - actually write to the header only when True""" + self.emit = emit + self.featureName = interface.get('name') + # If there is an additional 'protect' attribute in the feature, save it + self.featureExtraProtect = interface.get('protect') + + def endFeature(self): + """Finish an interface file, closing it when done. + + Derived classes responsible for emitting feature""" + self.featureName = None + self.featureExtraProtect = None + + def genRequirements(self, name, mustBeFound = True): + """Generate text showing what core versions and extensions introduce + an API. This exists in the base Generator class because it is used by + the shared enumerant-generating interfaces (buildEnumCDecl, etc.). + Here it returns an empty string for most generators, but can be + overridden by e.g. DocGenerator. + + - name - name of the API + - mustBeFound - If True, when requirements for 'name' cannot be + determined, a warning comment is generated. + """ + + return '' + + def validateFeature(self, featureType, featureName): + """Validate we are generating something only inside a `` tag""" + if self.featureName is None: + raise UserWarning('Attempt to generate', featureType, + featureName, 'when not in feature') + + def genType(self, typeinfo, name, alias): + """Generate interface for a type + + - typeinfo - TypeInfo for a type + + Extend to generate as desired in your derived class.""" + self.validateFeature('type', name) + + def genStruct(self, typeinfo, typeName, alias): + """Generate interface for a C "struct" type. + + - typeinfo - TypeInfo for a type interpreted as a struct + + Extend to generate as desired in your derived class.""" + self.validateFeature('struct', typeName) + + # The mixed-mode tags may contain no-op tags. + # It is convenient to remove them here where all output generators + # will benefit. + for member in typeinfo.elem.findall('.//member'): + for comment in member.findall('comment'): + member.remove(comment) + + def genGroup(self, groupinfo, groupName, alias): + """Generate interface for a group of enums (C "enum") + + - groupinfo - GroupInfo for a group. + + Extend to generate as desired in your derived class.""" + + self.validateFeature('group', groupName) + + def genEnum(self, enuminfo, typeName, alias): + """Generate interface for an enum (constant). + + - enuminfo - EnumInfo for an enum + - name - enum name + + Extend to generate as desired in your derived class.""" + self.validateFeature('enum', typeName) + + def genCmd(self, cmd, cmdinfo, alias): + """Generate interface for a command. + + - cmdinfo - CmdInfo for a command + + Extend to generate as desired in your derived class.""" + self.validateFeature('command', cmdinfo) + + def genSpirv(self, spirv, spirvinfo, alias): + """Generate interface for a spirv element. + + - spirvinfo - SpirvInfo for a command + + Extend to generate as desired in your derived class.""" + return + + def genFormat(self, format, formatinfo, alias): + """Generate interface for a format element. + + - formatinfo - FormatInfo + + Extend to generate as desired in your derived class.""" + return + + def makeProtoName(self, name, tail): + """Turn a `` `` into C-language prototype + and typedef declarations for that name. + + - name - contents of `` tag + - tail - whatever text follows that tag in the Element""" + return self.genOpts.apientry + name + tail + + def makeTypedefName(self, name, tail): + """Make the function-pointer typedef name for a command.""" + return '(' + self.genOpts.apientryp + 'PFN_' + name + tail + ')' + + def makeCParamDecl(self, param, aligncol): + """Return a string which is an indented, formatted + declaration for a `` or `` block (e.g. function parameter + or structure/union member). + + - param - Element (`` or ``) to format + - aligncol - if non-zero, attempt to align the nested `` element + at this column""" + indent = ' ' + paramdecl = indent + prefix = noneStr(param.text) + + for elem in param: + text = noneStr(elem.text) + tail = noneStr(elem.tail) + + if self.should_insert_may_alias_macro and self.genOpts.conventions.is_voidpointer_alias(elem.tag, text, tail): + # OpenXR-specific macro insertion - but not in apiinc for the spec + tail = self.genOpts.conventions.make_voidpointer_alias(tail) + if elem.tag == 'name' and aligncol > 0: + self.logMsg('diag', 'Aligning parameter', elem.text, 'to column', self.genOpts.alignFuncParam) + # Align at specified column, if possible + paramdecl = paramdecl.rstrip() + oldLen = len(paramdecl) + # This works around a problem where very long type names - + # longer than the alignment column - would run into the tail + # text. + paramdecl = paramdecl.ljust(aligncol - 1) + ' ' + newLen = len(paramdecl) + self.logMsg('diag', 'Adjust length of parameter decl from', oldLen, 'to', newLen, ':', paramdecl) + + if (self.misracppstyle() and prefix.find('const ') != -1): + # Change pointer type order from e.g. "const void *" to "void const *". + # If the string starts with 'const', reorder it to be after the first type. + paramdecl += prefix.replace('const ', '') + text + ' const' + tail + else: + paramdecl += prefix + text + tail + + # Clear prefix for subsequent iterations + prefix = '' + + paramdecl = paramdecl + prefix + + if aligncol == 0: + # Squeeze out multiple spaces other than the indentation + paramdecl = indent + ' '.join(paramdecl.split()) + return paramdecl + + def getCParamTypeLength(self, param): + """Return the length of the type field is an indented, formatted + declaration for a `` or `` block (e.g. function parameter + or structure/union member). + + - param - Element (`` or ``) to identify""" + + # Allow for missing tag + newLen = 0 + paramdecl = ' ' + noneStr(param.text) + for elem in param: + text = noneStr(elem.text) + tail = noneStr(elem.tail) + + if self.should_insert_may_alias_macro and self.genOpts.conventions.is_voidpointer_alias(elem.tag, text, tail): + # OpenXR-specific macro insertion + tail = self.genOpts.conventions.make_voidpointer_alias(tail) + if elem.tag == 'name': + # Align at specified column, if possible + newLen = len(paramdecl.rstrip()) + self.logMsg('diag', 'Identifying length of', elem.text, 'as', newLen) + paramdecl += text + tail + + return newLen + + def getMaxCParamTypeLength(self, info): + """Return the length of the longest type field for a member/parameter. + + - info - TypeInfo or CommandInfo. + """ + lengths = (self.getCParamTypeLength(member) + for member in info.getMembers()) + return max(lengths) + + def getHandleParent(self, typename): + """Get the parent of a handle object.""" + info = self.registry.typedict.get(typename) + if info is None: + return None + + elem = info.elem + if elem is not None: + return elem.get('parent') + + return None + + def iterateHandleAncestors(self, typename): + """Iterate through the ancestors of a handle type.""" + current = self.getHandleParent(typename) + while current is not None: + yield current + current = self.getHandleParent(current) + + def getHandleAncestors(self, typename): + """Get the ancestors of a handle object.""" + return list(self.iterateHandleAncestors(typename)) + + def getTypeCategory(self, typename): + """Get the category of a type.""" + info = self.registry.typedict.get(typename) + if info is None: + return None + + elem = info.elem + if elem is not None: + return elem.get('category') + return None + + def isStructAlwaysValid(self, structname): + """Try to do check if a structure is always considered valid (i.e. there is no rules to its acceptance).""" + # A conventions object is required for this call. + if not self.conventions: + raise RuntimeError("To use isStructAlwaysValid, be sure your options include a Conventions object.") + + if self.conventions.type_always_valid(structname): + return True + + category = self.getTypeCategory(structname) + if self.conventions.category_requires_validation(category): + return False + + info = self.registry.typedict.get(structname) + if info is None: + self.logMsg('error', f'isStructAlwaysValid({structname}) - structure not found in typedict') + + members = info.getMembers() + + for member in members: + member_name = getElemName(member) + if member_name in (self.conventions.structtype_member_name, + self.conventions.nextpointer_member_name): + return False + + if member.get('noautovalidity'): + return False + + member_type = getElemType(member) + + if member_type in ('void', 'char') or self.paramIsArray(member) or self.paramIsPointer(member): + return False + + if self.conventions.type_always_valid(member_type): + continue + + member_category = self.getTypeCategory(member_type) + + if self.conventions.category_requires_validation(member_category): + return False + + if member_category in ('struct', 'union'): + if self.isStructAlwaysValid(member_type) is False: + return False + + return True + + def isEnumRequired(self, elem): + """Return True if this `` element is + required, False otherwise + + - elem - `` element to test""" + required = elem.get('required') is not None + self.logMsg('diag', 'isEnumRequired:', elem.get('name'), + '->', required) + return required + + # @@@ This code is overridden by equivalent code now run in + # @@@ Registry.generateFeature + + required = False + + extname = elem.get('extname') + if extname is not None: + # 'supported' attribute was injected when the element was + # moved into the group in Registry.parseTree() + if self.genOpts.defaultExtensions == elem.get('supported'): + required = True + elif re.match(self.genOpts.addExtensions, extname) is not None: + required = True + elif elem.get('version') is not None: + required = re.match(self.genOpts.emitversions, elem.get('version')) is not None + else: + required = True + + return required + + def makeCDecls(self, cmd): + """Return C prototype and function pointer typedef for a + `` Element, as a two-element list of strings. + + - cmd - Element containing a `` tag""" + proto = cmd.find('proto') + params = cmd.findall('param') + # Begin accumulating prototype and typedef strings + pdecl = self.genOpts.apicall + tdecl = 'typedef ' + + # Insert the function return type/name. + # For prototypes, add APIENTRY macro before the name + # For typedefs, add (APIENTRY *) around the name and + # use the PFN_cmdnameproc naming convention. + # Done by walking the tree for element by element. + # etree has elem.text followed by (elem[i], elem[i].tail) + # for each child element and any following text + # Leading text + pdecl += noneStr(proto.text) + tdecl += noneStr(proto.text) + # For each child element, if it is a wrap in appropriate + # declaration. Otherwise append its contents and tail contents. + for elem in proto: + text = noneStr(elem.text) + tail = noneStr(elem.tail) + if elem.tag == 'name': + pdecl += self.makeProtoName(text, tail) + tdecl += self.makeTypedefName(text, tail) + else: + pdecl += text + tail + tdecl += text + tail + + if self.genOpts.alignFuncParam == 0: + # Squeeze out multiple spaces - there is no indentation + pdecl = ' '.join(pdecl.split()) + tdecl = ' '.join(tdecl.split()) + + # Now add the parameter declaration list, which is identical + # for prototypes and typedefs. Concatenate all the text from + # a node without the tags. No tree walking required + # since all tags are ignored. + # Uses: self.indentFuncProto + # self.indentFuncPointer + # self.alignFuncParam + n = len(params) + # Indented parameters + if n > 0: + indentdecl = '(\n' + indentdecl += ',\n'.join(self.makeCParamDecl(p, self.genOpts.alignFuncParam) + for p in params) + indentdecl += ');' + else: + indentdecl = '(void);' + # Non-indented parameters + paramdecl = '(' + if n > 0: + paramnames = [] + if self.misracppstyle(): + for p in params: + param = '' + firstIter = True; + for t in p.itertext(): + if (firstIter): + prefix = t + firstIter = False + else: + # Change pointer type order from e.g. "const void *" to "void const *". + # If the string starts with 'const', reorder it to be after the first type. + if (prefix.find('const ') != -1): + param += prefix.replace('const ', '') + t + ' const ' + else: + param += prefix + t + # Clear prefix for subsequent iterations + prefix = '' + paramnames.append(param); + else: + paramnames = (''.join(t for t in p.itertext()) + for p in params) + paramdecl += ', '.join(paramnames) + else: + paramdecl += 'void' + paramdecl += ");" + return [pdecl + indentdecl, tdecl + paramdecl] + + def newline(self): + """Print a newline to the output file (utility function)""" + write('', file=self.outFile) + + def setRegistry(self, registry): + self.registry = registry diff --git a/registry/genvk.py b/registry/genvk.py new file mode 100755 index 0000000..94370b2 --- /dev/null +++ b/registry/genvk.py @@ -0,0 +1,985 @@ +#!/usr/bin/python3 +# +# Copyright 2013-2021 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 + +import argparse +import pdb +import re +import sys +import copy +import time +import xml.etree.ElementTree as etree + +from json_parser import JSONParserGenerator, JSONParserOptions +from cgenerator import CGeneratorOptions, COutputGenerator +from schema_generator import SchemaGeneratorOptions, SchemaOutputGenerator +from json_generator import JSONGeneratorOptions, JSONOutputGenerator +from json_h_generator import JSONHeaderOutputGenerator, JSONHeaderGeneratorOptions +from json_c_generator import JSONCOutputGenerator, JSONCGeneratorOptions +from docgenerator import DocGeneratorOptions, DocOutputGenerator +from extensionmetadocgenerator import (ExtensionMetaDocGeneratorOptions, + ExtensionMetaDocOutputGenerator) +from interfacedocgenerator import InterfaceDocGenerator +from generator import write +from spirvcapgenerator import SpirvCapabilityOutputGenerator +from hostsyncgenerator import HostSynchronizationOutputGenerator +from formatsgenerator import FormatsOutputGenerator +from pygenerator import PyOutputGenerator +from rubygenerator import RubyOutputGenerator +from reflib import logDiag, logErr, logWarn, setLogFile +from reg import Registry +from validitygenerator import ValidityOutputGenerator +from apiconventions import APIConventions + + +# Simple timer functions +startTime = None + + +def startTimer(timeit): + global startTime + if timeit: + startTime = time.process_time() + + +def endTimer(timeit, msg): + global startTime + if timeit: + endTime = time.process_time() + logDiag(msg, endTime - startTime) + startTime = None + + +def makeREstring(strings, default=None, strings_are_regex=False): + """Turn a list of strings into a regexp string matching exactly those strings.""" + if strings or default is None: + if not strings_are_regex: + strings = (re.escape(s) for s in strings) + return '^(' + '|'.join(strings) + ')$' + return default + + +def makeGenOpts(args): + """Returns a directory of [ generator function, generator options ] indexed + by specified short names. The generator options incorporate the following + parameters: + + args is an parsed argument object; see below for the fields that are used.""" + global genOpts + genOpts = {} + + # Default class of extensions to include, or None + defaultExtensions = args.defaultExtensions + + # Additional extensions to include (list of extensions) + extensions = args.extension + + # Extensions to remove (list of extensions) + removeExtensions = args.removeExtensions + + # Extensions to emit (list of extensions) + emitExtensions = args.emitExtensions + + # SPIR-V capabilities / features to emit (list of extensions & capabilities) + emitSpirv = args.emitSpirv + + # Vulkan Formats to emit + emitFormats = args.emitFormats + + # Features to include (list of features) + features = args.feature + + # Whether to disable inclusion protect in headers + protect = args.protect + + # Output target directory + directory = args.directory + + # Path to generated files, particularly api.py + genpath = args.genpath + + # Generate MISRA C-friendly headers + misracstyle = args.misracstyle; + + # Generate MISRA C++-friendly headers + misracppstyle = args.misracppstyle; + + # Descriptive names for various regexp patterns used to select + # versions and extensions + allFormats = allSpirv = allFeatures = allExtensions = r'.*' + + # Turn lists of names/patterns into matching regular expressions + addExtensionsPat = makeREstring(extensions, None) + removeExtensionsPat = makeREstring(removeExtensions, None) + emitExtensionsPat = makeREstring(emitExtensions, allExtensions) + emitSpirvPat = makeREstring(emitSpirv, allSpirv) + emitFormatsPat = makeREstring(emitFormats, allFormats) + featuresPat = makeREstring(features, allFeatures) + + # Copyright text prefixing all headers (list of strings). + # The SPDX formatting below works around constraints of the 'reuse' tool + prefixStrings = [ + '/*', + '** Copyright 2015-2021 The Khronos Group Inc.', + '**', + '** SPDX' + '-License-Identifier: Apache-2.0', + '*/', + '' + ] + + # Text specific to Vulkan headers + vkPrefixStrings = [ + '/*', + '** This header is generated from the Khronos Vulkan XML API Registry.', + '**', + '*/', + '' + ] + + vulkanLayer = args.vulkanLayer + + # Defaults for generating re-inclusion protection wrappers (or not) + protectFile = protect + + # An API style conventions object + conventions = APIConventions() + + # Change this depending on which repository/spec we are building + defaultAPIName = conventions.xml_api_name + + isCTS = args.isCTS + + # API include files for spec and ref pages + # Overwrites include subdirectories in spec source tree + # The generated include files do not include the calling convention + # macros (apientry etc.), unlike the header files. + # Because the 1.0 core branch includes ref pages for extensions, + # all the extension interfaces need to be generated, even though + # none are used by the core spec itself. + genOpts['apiinc'] = [ + DocOutputGenerator, + DocGeneratorOptions( + conventions = conventions, + filename = 'timeMarker', + directory = directory, + genpath = genpath, + apiname = defaultAPIName, + profile = None, + versions = featuresPat, + emitversions = featuresPat, + defaultExtensions = None, + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + prefixText = prefixStrings + vkPrefixStrings, + apicall = '', + apientry = '', + apientryp = '*', + alignFuncParam = 48, + expandEnumerants = False) + ] + + # Python and Ruby representations of API information, used by scripts + # that do not need to load the full XML. + genOpts['api.py'] = [ + PyOutputGenerator, + DocGeneratorOptions( + conventions = conventions, + filename = 'api.py', + directory = directory, + genpath = None, + apiname = defaultAPIName, + profile = None, + versions = featuresPat, + emitversions = featuresPat, + defaultExtensions = None, + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + reparentEnums = False) + ] + + genOpts['api.rb'] = [ + RubyOutputGenerator, + DocGeneratorOptions( + conventions = conventions, + filename = 'api.rb', + directory = directory, + genpath = None, + apiname = defaultAPIName, + profile = None, + versions = featuresPat, + emitversions = featuresPat, + defaultExtensions = None, + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + reparentEnums = False) + ] + + + # API validity files for spec + # + # requireCommandAliases is set to True because we need validity files + # for the command something is promoted to even when the promoted-to + # feature is not included. This avoids wordy includes of validity files. + genOpts['validinc'] = [ + ValidityOutputGenerator, + DocGeneratorOptions( + conventions = conventions, + filename = 'timeMarker', + directory = directory, + genpath = None, + apiname = defaultAPIName, + profile = None, + versions = featuresPat, + emitversions = featuresPat, + defaultExtensions = None, + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + requireCommandAliases = True, + ) + ] + + # API host sync table files for spec + genOpts['hostsyncinc'] = [ + HostSynchronizationOutputGenerator, + DocGeneratorOptions( + conventions = conventions, + filename = 'timeMarker', + directory = directory, + genpath = None, + apiname = defaultAPIName, + profile = None, + versions = featuresPat, + emitversions = featuresPat, + defaultExtensions = None, + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + reparentEnums = False) + ] + + # Extension metainformation for spec extension appendices + # Includes all extensions by default, but only so that the generated + # 'promoted_extensions_*' files refer to all extensions that were + # promoted to a core version. + genOpts['extinc'] = [ + ExtensionMetaDocOutputGenerator, + ExtensionMetaDocGeneratorOptions( + conventions = conventions, + filename = 'timeMarker', + directory = directory, + genpath = None, + apiname = defaultAPIName, + profile = None, + versions = featuresPat, + emitversions = None, + defaultExtensions = defaultExtensions, + addExtensions = addExtensionsPat, + removeExtensions = None, + emitExtensions = emitExtensionsPat) + ] + + # Version and extension interface docs for version/extension appendices + # Includes all extensions by default. + genOpts['interfaceinc'] = [ + InterfaceDocGenerator, + DocGeneratorOptions( + conventions = conventions, + filename = 'timeMarker', + directory = directory, + genpath = None, + apiname = defaultAPIName, + profile = None, + versions = featuresPat, + emitversions = featuresPat, + defaultExtensions = None, + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + reparentEnums = False) + ] + + genOpts['spirvcapinc'] = [ + SpirvCapabilityOutputGenerator, + DocGeneratorOptions( + conventions = conventions, + filename = 'timeMarker', + directory = directory, + genpath = None, + apiname = defaultAPIName, + profile = None, + versions = featuresPat, + emitversions = featuresPat, + defaultExtensions = None, + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + emitSpirv = emitSpirvPat, + reparentEnums = False) + ] + + # Used to generate various format chapter tables + genOpts['formatsinc'] = [ + FormatsOutputGenerator, + DocGeneratorOptions( + conventions = conventions, + filename = 'timeMarker', + directory = directory, + genpath = None, + apiname = defaultAPIName, + profile = None, + versions = featuresPat, + emitversions = featuresPat, + defaultExtensions = None, + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + emitFormats = emitFormatsPat, + reparentEnums = False) + ] + + # Platform extensions, in their own header files + # Each element of the platforms[] array defines information for + # generating a single platform: + # [0] is the generated header file name + # [1] is the set of platform extensions to generate + # [2] is additional extensions whose interfaces should be considered, + # but suppressed in the output, to avoid duplicate definitions of + # dependent types like VkDisplayKHR and VkSurfaceKHR which come from + # non-platform extensions. + + # Track all platform extensions, for exclusion from vulkan_core.h + allPlatformExtensions = [] + + # Extensions suppressed for all WSI platforms (WSI extensions required + # by all platforms) + commonSuppressExtensions = [ 'VK_KHR_display', 'VK_KHR_swapchain' ] + + # Extensions required and suppressed for beta "platform". This can + # probably eventually be derived from the requires= attributes of + # the extension blocks. + betaRequireExtensions = [ + 'VK_KHR_portability_subset', + 'VK_KHR_video_queue', + 'VK_KHR_video_decode_queue', + 'VK_KHR_video_encode_queue', + 'VK_EXT_video_decode_h264', + 'VK_EXT_video_decode_h265', + 'VK_EXT_video_encode_h264', + 'VK_EXT_video_encode_h265', + ] + + betaSuppressExtensions = [] + + platforms = [ + [ 'vulkan_android.h', [ 'VK_KHR_android_surface', + 'VK_ANDROID_external_memory_android_hardware_buffer' + ], commonSuppressExtensions + + [ 'VK_KHR_format_feature_flags2', + ] ], + [ 'vulkan_fuchsia.h', [ 'VK_FUCHSIA_imagepipe_surface', + 'VK_FUCHSIA_external_memory', + 'VK_FUCHSIA_external_semaphore', + 'VK_FUCHSIA_buffer_collection' ], commonSuppressExtensions ], + [ 'vulkan_ggp.h', [ 'VK_GGP_stream_descriptor_surface', + 'VK_GGP_frame_token' ], commonSuppressExtensions ], + [ 'vulkan_ios.h', [ 'VK_MVK_ios_surface' ], commonSuppressExtensions ], + [ 'vulkan_macos.h', [ 'VK_MVK_macos_surface' ], commonSuppressExtensions ], + [ 'vulkan_vi.h', [ 'VK_NN_vi_surface' ], commonSuppressExtensions ], + [ 'vulkan_wayland.h', [ 'VK_KHR_wayland_surface' ], commonSuppressExtensions ], + [ 'vulkan_win32.h', [ 'VK_.*_win32(|_.*)', 'VK_EXT_full_screen_exclusive' ], + commonSuppressExtensions + + [ 'VK_KHR_external_semaphore', + 'VK_KHR_external_memory_capabilities', + 'VK_KHR_external_fence', + 'VK_KHR_external_fence_capabilities', + 'VK_KHR_get_surface_capabilities2', + 'VK_NV_external_memory_capabilities', + ] ], + [ 'vulkan_xcb.h', [ 'VK_KHR_xcb_surface' ], commonSuppressExtensions ], + [ 'vulkan_xlib.h', [ 'VK_KHR_xlib_surface' ], commonSuppressExtensions ], + [ 'vulkan_directfb.h', [ 'VK_EXT_directfb_surface' ], commonSuppressExtensions ], + [ 'vulkan_xlib_xrandr.h', [ 'VK_EXT_acquire_xlib_display' ], commonSuppressExtensions ], + [ 'vulkan_metal.h', [ 'VK_EXT_metal_surface' ], commonSuppressExtensions ], + [ 'vulkan_screen.h', [ 'VK_QNX_screen_surface' ], commonSuppressExtensions ], + [ 'vulkan_beta.h', betaRequireExtensions, betaSuppressExtensions ], + ] + + for platform in platforms: + headername = platform[0] + + allPlatformExtensions += platform[1] + + addPlatformExtensionsRE = makeREstring( + platform[1] + platform[2], strings_are_regex=True) + emitPlatformExtensionsRE = makeREstring( + platform[1], strings_are_regex=True) + + opts = CGeneratorOptions( + conventions = conventions, + filename = headername, + directory = directory, + genpath = None, + apiname = defaultAPIName, + profile = None, + versions = featuresPat, + emitversions = None, + defaultExtensions = None, + addExtensions = addPlatformExtensionsRE, + removeExtensions = None, + emitExtensions = emitPlatformExtensionsRE, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + alignFuncParam = 48, + misracstyle = misracstyle, + misracppstyle = misracppstyle) + + genOpts[headername] = [ COutputGenerator, opts ] + + # Header for core API + extensions. + # To generate just the core API, + # change to 'defaultExtensions = None' below. + # + # By default this adds all enabled, non-platform extensions. + # It removes all platform extensions (from the platform headers options + # constructed above) as well as any explicitly specified removals. + + removeExtensionsPat = makeREstring( + allPlatformExtensions + removeExtensions, None, strings_are_regex=True) + + genOpts['vulkan_core.h'] = [ + COutputGenerator, + CGeneratorOptions( + conventions = conventions, + filename = 'vulkan_core.h', + directory = directory, + genpath = None, + apiname = defaultAPIName, + profile = None, + versions = featuresPat, + emitversions = featuresPat, + defaultExtensions = defaultExtensions, + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + alignFuncParam = 48, + misracstyle = misracstyle, + misracppstyle = misracppstyle) + ] + + # Temporary, to compare interfaces with vulkan_sc_core.h + noExtensions = makeREstring(['None']) + newOpts = copy.deepcopy(genOpts['vulkan_core.h']) + newOpts[1].filename = 'vk11.h' + newOpts[1].defaultExtensions = None + newOpts[1].emitExtensions = emitExtensionsPat + genOpts['vk11.h'] = newOpts + + # Vulkan versions to include for SC header - SC *removes* features from 1.0/1.1/1.2 + scVersions = makeREstring(['VK_VERSION_1_0', 'VK_VERSION_1_1', 'VK_VERSION_1_2', 'VKSC_VERSION_1_0']) + + genOpts['vulkan_sc_core.h'] = [ + COutputGenerator, + CGeneratorOptions( + conventions = conventions, + filename = 'vulkan_sc_core.h', + directory = directory, + apiname = 'vulkansc', + profile = None, + versions = scVersions, + emitversions = scVersions, + defaultExtensions = 'vulkansc', + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + alignFuncParam = 48, + misracstyle = misracstyle, + misracppstyle = misracppstyle) + ] + + genOpts['vulkan_sc_core.hpp'] = [ + COutputGenerator, + CGeneratorOptions( + conventions = conventions, + filename = 'vulkan_sc_core.hpp', + directory = directory, + apiname = 'vulkansc', + profile = None, + versions = scVersions, + emitversions = scVersions, + defaultExtensions = 'vulkansc', + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + alignFuncParam = 48, + misracstyle = misracstyle, + misracppstyle = misracppstyle) + ] + + genOpts['vk.json'] = [ + SchemaOutputGenerator, + SchemaGeneratorOptions( + conventions = conventions, + filename = 'vk.json', + directory = directory, + apiname = 'vulkansc', + profile = None, + versions = scVersions, + emitversions = scVersions, + defaultExtensions = 'vulkansc', + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + alignFuncParam = 48) + ] + + if vulkanLayer: + genOpts['vulkan_json_data.hpp'] = [ + JSONOutputGenerator, + JSONGeneratorOptions( + conventions = conventions, + filename = 'vulkan_json_data.hpp', + directory = directory, + apiname = 'vulkan', + profile = None, + versions = featuresPat, + emitversions = featuresPat, + defaultExtensions = defaultExtensions, + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + vulkanLayer = vulkanLayer, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + alignFuncParam = 48) + ] + else: + genOpts['vulkan_json_data.hpp'] = [ + JSONOutputGenerator, + JSONGeneratorOptions( + conventions = conventions, + filename = 'vulkan_json_data.hpp', + directory = directory, + apiname = 'vulkansc', + profile = None, + versions = scVersions, + emitversions = scVersions, + defaultExtensions = 'vulkansc', + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + vulkanLayer = vulkanLayer, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + isCTS = isCTS, + alignFuncParam = 48) + ] + + # Raw C header file generator. + genOpts['vulkan_json_gen.h'] = [ + JSONHeaderOutputGenerator, + JSONHeaderGeneratorOptions( + conventions = conventions, + filename = 'vulkan_json_gen.h', + directory = directory, + apiname = 'vulkansc', + profile = None, + versions = scVersions, + emitversions = scVersions, + defaultExtensions = 'vulkansc', + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + alignFuncParam = 48) + ] + + # Raw C source file generator. + genOpts['vulkan_json_gen.c'] = [ + JSONCOutputGenerator, + JSONCGeneratorOptions( + conventions = conventions, + filename = 'vulkan_json_gen.c', + directory = directory, + apiname = 'vulkansc', + profile = None, + versions = scVersions, + emitversions = scVersions, + defaultExtensions = 'vulkansc', + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + alignFuncParam = 48) + ] + + genOpts['vulkan_json_parser.hpp'] = [ + JSONParserGenerator, + JSONParserOptions( + conventions = conventions, + filename = 'vulkan_json_parser.hpp', + directory = directory, + apiname = 'vulkansc', + profile = None, + versions = scVersions, + emitversions = scVersions, + defaultExtensions = 'vulkansc', + addExtensions = addExtensionsPat, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + isCTS = isCTS, + alignFuncParam = 48) + ] + + # Unused - vulkan10.h target. + # It is possible to generate a header with just the Vulkan 1.0 + + # extension interfaces defined, but since the promoted KHR extensions + # are now defined in terms of the 1.1 interfaces, such a header is very + # similar to vulkan_core.h. + genOpts['vulkan10.h'] = [ + COutputGenerator, + CGeneratorOptions( + conventions = conventions, + filename = 'vulkan10.h', + directory = directory, + genpath = None, + apiname = defaultAPIName, + profile = None, + versions = 'VK_VERSION_1_0', + emitversions = 'VK_VERSION_1_0', + defaultExtensions = None, + addExtensions = None, + removeExtensions = None, + emitExtensions = None, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + alignFuncParam = 48, + misracstyle = misracstyle, + misracppstyle = misracppstyle) + ] + + # Unused - vulkan11.h target. + # It is possible to generate a header with just the Vulkan 1.0 + + # extension interfaces defined, but since the promoted KHR extensions + # are now defined in terms of the 1.1 interfaces, such a header is very + # similar to vulkan_core.h. + genOpts['vulkan11.h'] = [ + COutputGenerator, + CGeneratorOptions( + conventions = conventions, + filename = 'vulkan11.h', + directory = directory, + genpath = None, + apiname = defaultAPIName, + profile = None, + versions = '^VK_VERSION_1_[01]$', + emitversions = '^VK_VERSION_1_[01]$', + defaultExtensions = None, + addExtensions = None, + removeExtensions = None, + emitExtensions = None, + prefixText = prefixStrings + vkPrefixStrings, + genFuncPointers = True, + protectFile = protectFile, + protectFeature = False, + protectProto = '#ifndef', + protectProtoStr = 'VK_NO_PROTOTYPES', + apicall = 'VKAPI_ATTR ', + apientry = 'VKAPI_CALL ', + apientryp = 'VKAPI_PTR *', + alignFuncParam = 48, + misracstyle = misracstyle, + misracppstyle = misracppstyle) + ] + + genOpts['alias.h'] = [ + COutputGenerator, + CGeneratorOptions( + conventions = conventions, + filename = 'alias.h', + directory = directory, + genpath = None, + apiname = defaultAPIName, + profile = None, + versions = featuresPat, + emitversions = featuresPat, + defaultExtensions = defaultExtensions, + addExtensions = None, + removeExtensions = removeExtensionsPat, + emitExtensions = emitExtensionsPat, + prefixText = None, + genFuncPointers = False, + protectFile = False, + protectFeature = False, + protectProto = '', + protectProtoStr = '', + apicall = '', + apientry = '', + apientryp = '', + alignFuncParam = 36) + ] + + +def genTarget(args): + """Create an API generator and corresponding generator options based on + the requested target and command line options. + + This is encapsulated in a function so it can be profiled and/or timed. + The args parameter is an parsed argument object containing the following + fields that are used: + + - target - target to generate + - directory - directory to generate it in + - protect - True if re-inclusion wrappers should be created + - extensions - list of additional extensions to include in generated interfaces""" + + # Create generator options with parameters specified on command line + makeGenOpts(args) + + # pdb.set_trace() + + # Select a generator matching the requested target + if args.target in genOpts: + createGenerator = genOpts[args.target][0] + options = genOpts[args.target][1] + + logDiag('* Building', options.filename) + logDiag('* options.versions =', options.versions) + logDiag('* options.emitversions =', options.emitversions) + logDiag('* options.defaultExtensions =', options.defaultExtensions) + logDiag('* options.addExtensions =', options.addExtensions) + logDiag('* options.removeExtensions =', options.removeExtensions) + logDiag('* options.emitExtensions =', options.emitExtensions) + logDiag('* options.emitSpirv =', options.emitSpirv) + logDiag('* options.emitFormats =', options.emitFormats) + + gen = createGenerator(errFile=errWarn, + warnFile=errWarn, + diagFile=diag) + return (gen, options) + else: + logErr('No generator options for unknown target:', args.target) + return None + + +# -feature name +# -extension name +# For both, "name" may be a single name, or a space-separated list +# of names, or a regular expression. +if __name__ == '__main__': + parser = argparse.ArgumentParser() + + parser.add_argument('-defaultExtensions', action='store', + default=APIConventions().xml_api_name, + help='Specify a single class of extensions to add to targets') + parser.add_argument('-extension', action='append', + default=[], + help='Specify an extension or extensions to add to targets') + parser.add_argument('-removeExtensions', action='append', + default=[], + help='Specify an extension or extensions to remove from targets') + parser.add_argument('-emitExtensions', action='append', + default=[], + help='Specify an extension or extensions to emit in targets') + parser.add_argument('-emitSpirv', action='append', + default=[], + help='Specify a SPIR-V extension or capability to emit in targets') + parser.add_argument('-emitFormats', action='append', + default=[], + help='Specify Vulkan Formats to emit in targets') + parser.add_argument('-feature', action='append', + default=[], + help='Specify a core API feature name or names to add to targets') + parser.add_argument('-debug', action='store_true', + help='Enable debugging') + parser.add_argument('-dump', action='store_true', + help='Enable dump to stderr') + parser.add_argument('-diagfile', action='store', + default=None, + help='Write diagnostics to specified file') + parser.add_argument('-errfile', action='store', + default=None, + help='Write errors and warnings to specified file instead of stderr') + parser.add_argument('-noprotect', dest='protect', action='store_false', + help='Disable inclusion protection in output headers') + parser.add_argument('-profile', action='store_true', + help='Enable profiling') + parser.add_argument('-registry', action='store', + default='vk.xml', + help='Use specified registry file instead of vk.xml') + parser.add_argument('-time', action='store_true', + help='Enable timing') + parser.add_argument('-validate', action='store_true', + help='Validate the registry properties and exit') + parser.add_argument('-genpath', action='store', default='gen', + help='Path to generated files') + parser.add_argument('-o', action='store', dest='directory', + default='.', + help='Create target and related files in specified directory') + parser.add_argument('target', metavar='target', nargs='?', + help='Specify target') + parser.add_argument('-quiet', action='store_true', default=True, + help='Suppress script output during normal execution.') + parser.add_argument('-verbose', action='store_false', dest='quiet', default=True, + help='Enable script output during normal execution.') + parser.add_argument('--vulkanLayer', action='store_true', dest='vulkanLayer', + help='Enable scripts to generate VK specific vulkan_json_data.hpp for json_gen_layer.') + parser.add_argument('-misracstyle', dest='misracstyle', action='store_true', + help='generate MISRA C-friendly headers') + parser.add_argument('-misracppstyle', dest='misracppstyle', action='store_true', + help='generate MISRA C++-friendly headers') + parser.add_argument('--iscts', action='store_true', dest='isCTS', + help='Specify if this should generate CTS compatible code') + + args = parser.parse_args() + + # This splits arguments which are space-separated lists + args.feature = [name for arg in args.feature for name in arg.split()] + args.extension = [name for arg in args.extension for name in arg.split()] + + # create error/warning & diagnostic files + if args.errfile: + errWarn = open(args.errfile, 'w', encoding='utf-8') + else: + errWarn = sys.stderr + + if args.diagfile: + diag = open(args.diagfile, 'w', encoding='utf-8') + else: + diag = None + + if args.time: + # Log diagnostics and warnings + setLogFile(setDiag = True, setWarn = True, filename = '-') + + (gen, options) = (None, None) + if not args.validate: + # Create the API generator & generator options + (gen, options) = genTarget(args) + + # Create the registry object with the specified generator and generator + # options. The options are set before XML loading as they may affect it. + reg = Registry(gen, options) + + # Parse the specified registry XML into an ElementTree object + startTimer(args.time) + tree = etree.parse(args.registry) + endTimer(args.time, '* Time to make ElementTree =') + + # Load the XML tree into the registry object + startTimer(args.time) + reg.loadElementTree(tree) + endTimer(args.time, '* Time to parse ElementTree =') + + if args.validate: + success = reg.validateRegistry() + sys.exit(0 if success else 1) + + if args.dump: + logDiag('* Dumping registry to regdump.txt') + reg.dumpReg(filehandle=open('regdump.txt', 'w', encoding='utf-8')) + + # Finally, use the output generator to create the requested target + if args.debug: + pdb.run('reg.apiGen()') + else: + startTimer(args.time) + reg.apiGen() + endTimer(args.time, '* Time to generate ' + options.filename + ' =') + + if not args.quiet: + logDiag('* Generated', options.filename) diff --git a/registry/reg.py b/registry/reg.py new file mode 100644 index 0000000..bcaaa82 --- /dev/null +++ b/registry/reg.py @@ -0,0 +1,1600 @@ +#!/usr/bin/python3 -i +# +# Copyright 2013-2021 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 + +"""Types and classes for manipulating an API registry.""" + +import copy +import re +import sys +import xml.etree.ElementTree as etree +from collections import defaultdict, deque, namedtuple +from generator import OutputGenerator, GeneratorOptions, write +from apiconventions import APIConventions + +def apiNameMatch(str, supported): + """Return whether a required api name matches a pattern specified for an + XML 'api' attribute or 'supported' attribute. + + - str - API name such as 'vulkan' or 'openxr'. May be None, in which + case it never matches (this should not happen). + - supported - comma-separated list of XML API names. May be None, in + which case str always matches (this is the usual case).""" + + if str is not None: + return supported is None or str in supported.split(',') + + # Fallthrough case - either str is None or the test failed + return False + +def matchAPIProfile(api, profile, elem): + """Return whether an API and profile + being generated matches an element's profile + + - api - string naming the API to match + - profile - string naming the profile to match + - elem - Element which (may) have 'api' and 'profile' + attributes to match to. + + If a tag is not present in the Element, the corresponding API + or profile always matches. + + Otherwise, the tag must exactly match the API or profile. + + Thus, if 'profile' = core: + + - `` with no attribute will match + - `` will match + - `` will not match + + Possible match conditions: + + ``` + Requested Element + Profile Profile + --------- -------- + None None Always matches + 'string' None Always matches + None 'string' Does not match. Cannot generate multiple APIs + or profiles, so if an API/profile constraint + is present, it must be asked for explicitly. + 'string' 'string' Strings must match + ``` + + ** In the future, we will allow regexes for the attributes, + not just strings, so that `api="^(gl|gles2)"` will match. Even + this is not really quite enough, we might prefer something + like `"gl(core)|gles1(common-lite)"`.""" + # Match 'api', if present + elem_api = elem.get('api') + if elem_api: + if api is None: + raise UserWarning("No API requested, but 'api' attribute is present with value '" + + elem_api + "'") + elif api != elem_api: + # Requested API does not match attribute + return False + elem_profile = elem.get('profile') + if elem_profile: + if profile is None: + raise UserWarning("No profile requested, but 'profile' attribute is present with value '" + + elem_profile + "'") + elif profile != elem_profile: + # Requested profile does not match attribute + return False + return True + + +def stripNonmatchingAPIs(tree, apiName, actuallyDelete = True): + """Remove tree Elements with 'api' attributes matching apiName. + + tree - Element at the root of the hierarchy to strip. Only its + children can actually be removed, not the tree itself. + apiName - string which much match a command-separated component of + the 'api' attribute. + actuallyDelete - only delete matching elements if True.""" + + stack = deque() + stack.append(tree) + + while len(stack) > 0: + parent = stack.pop() + + for child in parent.findall('*'): + api = child.get('api') + + if apiNameMatch(apiName, api): + # Add child to the queue + stack.append(child) + elif not apiNameMatch(apiName, api): + # Child does not match requested api. Remove it. + if actuallyDelete: + parent.remove(child) + + +class BaseInfo: + """Base class for information about a registry feature + (type/group/enum/command/API/extension). + + Represents the state of a registry feature, used during API generation. + """ + + def __init__(self, elem): + self.required = False + """should this feature be defined during header generation + (has it been removed by a profile or version)?""" + + self.declared = False + "has this feature been defined already?" + + self.elem = elem + "etree Element for this feature" + + def resetState(self): + """Reset required/declared to initial values. Used + prior to generating a new API interface.""" + self.required = False + self.declared = False + + def compareKeys(self, info, key, required = False): + """Return True if self.elem and info.elem have the same attribute + value for key. + If 'required' is not True, also returns True if neither element + has an attribute value for key.""" + + if required and key not in self.elem.keys(): + return False + return self.elem.get(key) == info.elem.get(key) + + def compareElem(self, info, infoName): + """Return True if self.elem and info.elem have the same definition. + info - the other object + infoName - 'type' / 'group' / 'enum' / 'command' / 'feature' / + 'extension'""" + + if infoName == 'enum': + if self.compareKeys(info, 'extends'): + # Either both extend the same type, or no type + if (self.compareKeys(info, 'value', required = True) or + self.compareKeys(info, 'bitpos', required = True)): + # If both specify the same value or bit position, + # they are equal + return True + elif (self.compareKeys(info, 'extnumber') and + self.compareKeys(info, 'offset') and + self.compareKeys(info, 'dir')): + # If both specify the same relative offset, they are equal + return True + elif (self.compareKeys(info, 'alias')): + # If both are aliases of the same value + return True + else: + return False + else: + # The same enum cannot extend two different types + return False + else: + # Non-s should never be redefined + return False + + +class TypeInfo(BaseInfo): + """Registry information about a type. No additional state + beyond BaseInfo is required.""" + + def __init__(self, elem): + BaseInfo.__init__(self, elem) + self.additionalValidity = [] + self.removedValidity = [] + + def getMembers(self): + """Get a collection of all member elements for this type, if any.""" + return self.elem.findall('member') + + def resetState(self): + BaseInfo.resetState(self) + self.additionalValidity = [] + self.removedValidity = [] + + +class GroupInfo(BaseInfo): + """Registry information about a group of related enums + in an block, generally corresponding to a C "enum" type.""" + + def __init__(self, elem): + BaseInfo.__init__(self, elem) + + +class EnumInfo(BaseInfo): + """Registry information about an enum""" + + def __init__(self, elem): + BaseInfo.__init__(self, elem) + self.type = elem.get('type') + """numeric type of the value of the tag + ( '' for GLint, 'u' for GLuint, 'ull' for GLuint64 )""" + if self.type is None: + self.type = '' + + +class CmdInfo(BaseInfo): + """Registry information about a command""" + + def __init__(self, elem): + BaseInfo.__init__(self, elem) + self.additionalValidity = [] + self.removedValidity = [] + + def getParams(self): + """Get a collection of all param elements for this command, if any.""" + return self.elem.findall('param') + + def resetState(self): + BaseInfo.resetState(self) + self.additionalValidity = [] + self.removedValidity = [] + + +class FeatureInfo(BaseInfo): + """Registry information about an API + or .""" + + def __init__(self, elem): + BaseInfo.__init__(self, elem) + self.name = elem.get('name') + "feature name string (e.g. 'VK_KHR_surface')" + + self.emit = False + "has this feature been defined already?" + + self.sortorder = int(elem.get('sortorder', 0)) + """explicit numeric sort key within feature and extension groups. + Defaults to 0.""" + + # Determine element category (vendor). Only works + # for elements. + if elem.tag == 'feature': + # Element category (vendor) is meaningless for + self.category = 'VERSION' + """category, e.g. VERSION or khr/vendor tag""" + + self.version = elem.get('name') + """feature name string""" + + self.versionNumber = elem.get('number') + """versionNumber - API version number, taken from the 'number' + attribute of . Extensions do not have API version + numbers and are assigned number 0.""" + + self.number = "0" + self.supported = None + else: + # Extract vendor portion of __ + self.category = self.name.split('_', 2)[1] + self.version = "0" + self.versionNumber = "0" + self.number = elem.get('number') + """extension number, used for ordering and for assigning + enumerant offsets. features do not have extension + numbers and are assigned number 0.""" + + # If there is no 'number' attribute, use 0, so sorting works + if self.number is None: + self.number = 0 + self.supported = elem.get('supported') + +class SpirvInfo(BaseInfo): + """Registry information about an API + or .""" + + def __init__(self, elem): + BaseInfo.__init__(self, elem) + +class FormatInfo(BaseInfo): + """Registry information about an API .""" + + def __init__(self, elem): + BaseInfo.__init__(self, elem) + +class Registry: + """Object representing an API registry, loaded from an XML file.""" + + def __init__(self, gen=None, genOpts=None): + if gen is None: + # If not specified, give a default object so messaging will work + self.gen = OutputGenerator() + else: + self.gen = gen + "Output generator used to write headers / messages" + + if genOpts is None: + # If no generator is provided, we may still need the XML API name + # (for example, in genRef.py). + self.genOpts = GeneratorOptions(apiname = APIConventions().xml_api_name) + else: + self.genOpts = genOpts + "Options controlling features to write and how to format them" + + self.gen.registry = self + self.gen.genOpts = self.genOpts + self.gen.genOpts.registry = self + + self.tree = None + "ElementTree containing the root ``" + + self.typedict = {} + "dictionary of TypeInfo objects keyed by type name" + + self.groupdict = {} + "dictionary of GroupInfo objects keyed by group name" + + self.enumdict = {} + "dictionary of EnumInfo objects keyed by enum name" + + self.cmddict = {} + "dictionary of CmdInfo objects keyed by command name" + + self.apidict = {} + "dictionary of FeatureInfo objects for `` elements keyed by API name" + + self.extensions = [] + "list of `` Elements" + + self.extdict = {} + "dictionary of FeatureInfo objects for `` elements keyed by extension name" + + self.spirvextdict = {} + "dictionary of FeatureInfo objects for `` elements keyed by spirv extension name" + + self.spirvcapdict = {} + "dictionary of FeatureInfo objects for `` elements keyed by spirv capability name" + + self.formatsdict = {} + "dictionary of FeatureInfo objects for `` elements keyed by VkFormat name" + + self.emitFeatures = False + """True to actually emit features for a version / extension, + or False to just treat them as emitted""" + + self.breakPat = None + "regexp pattern to break on when generating names" + # self.breakPat = re.compile('VkFenceImportFlagBits.*') + + self.requiredextensions = [] # Hack - can remove it after validity generator goes away + + # ** Global types for automatic source generation ** + # Length Member data + self.commandextensiontuple = namedtuple('commandextensiontuple', + ['command', # The name of the command being modified + 'value', # The value to append to the command + 'extension']) # The name of the extension that added it + self.validextensionstructs = defaultdict(list) + self.commandextensionsuccesses = [] + self.commandextensionerrors = [] + + self.filename = None + + def loadElementTree(self, tree): + """Load ElementTree into a Registry object and parse it.""" + self.tree = tree + self.parseTree() + + def loadFile(self, file): + """Load an API registry XML file into a Registry object and parse it""" + self.filename = file + self.tree = etree.parse(file) + self.parseTree() + + def setGenerator(self, gen): + """Specify output generator object. + + `None` restores the default generator.""" + self.gen = gen + self.gen.setRegistry(self) + + def addElementInfo(self, elem, info, infoName, dictionary): + """Add information about an element to the corresponding dictionary. + + Intended for internal use only. + + - elem - ``/``/``/``/``/``/``/``/`` Element + - info - corresponding {Type|Group|Enum|Cmd|Feature|Spirv}Info object + - infoName - 'type' / 'group' / 'enum' / 'command' / 'feature' / 'extension' / 'spirvextension' / 'spirvcapability' / 'format' + - dictionary - self.{type|group|enum|cmd|api|ext|format|spirvext|spirvcap}dict + + The dictionary key is the element 'name' attribute.""" + + # self.gen.logMsg('diag', 'Adding ElementInfo.required =', + # info.required, 'name =', elem.get('name')) + key = elem.get('name') + if key in dictionary: + if not dictionary[key].compareElem(info, infoName): + self.gen.logMsg('warn', 'Attempt to redefine', key, + '(this should not happen)') + else: + dictionary[key] = info + + def lookupElementInfo(self, fname, dictionary): + """Find a {Type|Enum|Cmd}Info object by name. + + Intended for internal use only. + + If an object qualified by API name exists, use that. + + - fname - name of type / enum / command + - dictionary - self.{type|enum|cmd}dict""" + key = (fname, self.genOpts.apiname) + if key in dictionary: + # self.gen.logMsg('diag', 'Found API-specific element for feature', fname) + return dictionary[key] + if fname in dictionary: + # self.gen.logMsg('diag', 'Found generic element for feature', fname) + return dictionary[fname] + + return None + + def breakOnName(self, regexp): + """Specify a feature name regexp to break on when generating features.""" + self.breakPat = re.compile(regexp) + + def parseTree(self): + """Parse the registry Element, once created""" + # This must be the Element for the root + self.reg = self.tree.getroot() + + # Preprocess the tree by removing all elements with non-matching + # 'api' attributes by breadth-first tree traversal. + # This is a blunt hammer, but eliminates the need to track and test + # the apis deeper in processing to select the correct elements and + # avoid duplicates. + # Schema validation should prevent duplicate elements with + # overlapping api attributes, or where one element has an api + # attribute and the other does not. + + stripNonmatchingAPIs(self.reg, self.genOpts.apiname, actuallyDelete = True) + + # Create dictionary of registry types from toplevel tags + # and add 'name' attribute to each tag (where missing) + # based on its element. + # + # There is usually one block; more are OK + # Required attributes: 'name' or nested tag contents + self.typedict = {} + for type_elem in self.reg.findall('types/type'): + # If the does not already have a 'name' attribute, set + # it from contents of its tag. + if type_elem.get('name') is None: + type_elem.set('name', type_elem.find('name').text) + self.addElementInfo(type_elem, TypeInfo(type_elem), 'type', self.typedict) + + # Create dictionary of registry enum groups from tags. + # + # Required attributes: 'name'. If no name is given, one is + # generated, but that group cannot be identified and turned into an + # enum type definition - it is just a container for tags. + self.groupdict = {} + for group in self.reg.findall('enums'): + self.addElementInfo(group, GroupInfo(group), 'group', self.groupdict) + + # Create dictionary of registry enums from tags + # + # tags usually define different namespaces for the values + # defined in those tags, but the actual names all share the + # same dictionary. + # Required attributes: 'name', 'value' + # For containing which have type="enum" or type="bitmask", + # tag all contained s are required. This is a stopgap until + # a better scheme for tagging core and extension enums is created. + self.enumdict = {} + for enums in self.reg.findall('enums'): + required = (enums.get('type') is not None) + for enum in enums.findall('enum'): + enumInfo = EnumInfo(enum) + enumInfo.required = required + self.addElementInfo(enum, enumInfo, 'enum', self.enumdict) + + # Create dictionary of registry commands from tags + # and add 'name' attribute to each tag (where missing) + # based on its element. + # + # There is usually only one block; more are OK. + # Required attributes: 'name' or tag contents + self.cmddict = {} + # List of commands which alias others. Contains + # [ aliasName, element ] + # for each alias + cmdAlias = [] + for cmd in self.reg.findall('commands/command'): + # If the does not already have a 'name' attribute, set + # it from contents of its tag. + name = cmd.get('name') + if name is None: + name = cmd.set('name', cmd.find('proto/name').text) + ci = CmdInfo(cmd) + self.addElementInfo(cmd, ci, 'command', self.cmddict) + alias = cmd.get('alias') + if alias: + cmdAlias.append([name, alias, cmd]) + + # Now loop over aliases, injecting a copy of the aliased command's + # Element with the aliased prototype name replaced with the command + # name - if it exists. + for (name, alias, cmd) in cmdAlias: + if alias in self.cmddict: + aliasInfo = self.cmddict[alias] + cmdElem = copy.deepcopy(aliasInfo.elem) + cmdElem.find('proto/name').text = name + cmdElem.set('name', name) + cmdElem.set('alias', alias) + ci = CmdInfo(cmdElem) + # Replace the dictionary entry for the CmdInfo element + self.cmddict[name] = ci + + # @ newString = etree.tostring(base, encoding="unicode").replace(aliasValue, aliasName) + # @elem.append(etree.fromstring(replacement)) + else: + self.gen.logMsg('warn', 'No matching found for command', + cmd.get('name'), 'alias', alias) + + # Create dictionaries of API and extension interfaces + # from toplevel and tags. + self.apidict = {} + for feature in self.reg.findall('feature'): + featureInfo = FeatureInfo(feature) + self.addElementInfo(feature, featureInfo, 'feature', self.apidict) + + # Add additional enums defined only in tags + # to the corresponding enumerated type. + # When seen here, the element, processed to contain the + # numeric enum value, is added to the corresponding + # element, as well as adding to the enum dictionary. It is no + # longer removed from the element it is introduced in. + # Instead, generateRequiredInterface ignores elements + # that extend enumerated types. + # + # For tags which are actually just constants, if there is + # no 'extends' tag but there is a 'value' or 'bitpos' tag, just + # add an EnumInfo record to the dictionary. That works because + # output generation of constants is purely dependency-based, and + # does not need to iterate through the XML tags. + for elem in feature.findall('require'): + for enum in elem.findall('enum'): + addEnumInfo = False + groupName = enum.get('extends') + if groupName is not None: + # self.gen.logMsg('diag', 'Found extension enum', + # enum.get('name')) + # Add version number attribute to the element + enum.set('version', featureInfo.version) + # Look up the GroupInfo with matching groupName + if groupName in self.groupdict: + # self.gen.logMsg('diag', 'Matching group', + # groupName, 'found, adding element...') + gi = self.groupdict[groupName] + gi.elem.append(copy.deepcopy(enum)) + else: + self.gen.logMsg('warn', 'NO matching group', + groupName, 'for enum', enum.get('name'), 'found.') + addEnumInfo = True + elif enum.get('value') or enum.get('bitpos') or enum.get('alias'): + # self.gen.logMsg('diag', 'Adding extension constant "enum"', + # enum.get('name')) + addEnumInfo = True + if addEnumInfo: + enumInfo = EnumInfo(enum) + self.addElementInfo(enum, enumInfo, 'enum', self.enumdict) + + self.extensions = self.reg.findall('extensions/extension') + self.extdict = {} + for feature in self.extensions: + featureInfo = FeatureInfo(feature) + self.addElementInfo(feature, featureInfo, 'extension', self.extdict) + + # Add additional enums defined only in tags + # to the corresponding core type. + # Algorithm matches that of enums in a "feature" tag as above. + # + # This code also adds a 'extnumber' attribute containing the + # extension number, used for enumerant value calculation. + for elem in feature.findall('require'): + for enum in elem.findall('enum'): + addEnumInfo = False + groupName = enum.get('extends') + if groupName is not None: + # self.gen.logMsg('diag', 'Found extension enum', + # enum.get('name')) + + # Add block's extension number attribute to + # the element unless specified explicitly, such + # as when redefining an enum in another extension. + extnumber = enum.get('extnumber') + if not extnumber: + enum.set('extnumber', featureInfo.number) + + enum.set('extname', featureInfo.name) + enum.set('supported', featureInfo.supported) + # Look up the GroupInfo with matching groupName + if groupName in self.groupdict: + # self.gen.logMsg('diag', 'Matching group', + # groupName, 'found, adding element...') + gi = self.groupdict[groupName] + gi.elem.append(copy.deepcopy(enum)) + else: + self.gen.logMsg('warn', 'NO matching group', + groupName, 'for enum', enum.get('name'), 'found.') + addEnumInfo = True + elif enum.get('value') or enum.get('bitpos') or enum.get('alias'): + # self.gen.logMsg('diag', 'Adding extension constant "enum"', + # enum.get('name')) + addEnumInfo = True + if addEnumInfo: + enumInfo = EnumInfo(enum) + self.addElementInfo(enum, enumInfo, 'enum', self.enumdict) + + # Construct a "validextensionstructs" list for parent structures + # based on "structextends" tags in child structures + disabled_types = [] + for disabled_ext in self.reg.findall('extensions/extension[@supported="disabled"]'): + for type_elem in disabled_ext.findall("*/type"): + disabled_types.append(type_elem.get('name')) + for type_elem in self.reg.findall('types/type'): + if type_elem.get('name') not in disabled_types: + parentStructs = type_elem.get('structextends') + if parentStructs is not None: + for parent in parentStructs.split(','): + # self.gen.logMsg('diag', type.get('name'), 'extends', parent) + self.validextensionstructs[parent].append(type_elem.get('name')) + # Sort the lists so they do not depend on the XML order + for parent in self.validextensionstructs: + self.validextensionstructs[parent].sort() + + # Parse out all spirv tags in dictionaries + # Use addElementInfo to catch duplicates + for spirv in self.reg.findall('spirvextensions/spirvextension'): + spirvInfo = SpirvInfo(spirv) + self.addElementInfo(spirv, spirvInfo, 'spirvextension', self.spirvextdict) + for spirv in self.reg.findall('spirvcapabilities/spirvcapability'): + spirvInfo = SpirvInfo(spirv) + self.addElementInfo(spirv, spirvInfo, 'spirvcapability', self.spirvcapdict) + + for format in self.reg.findall('formats/format'): + formatInfo = FormatInfo(format) + self.addElementInfo(format, formatInfo, 'format', self.formatsdict) + + def dumpReg(self, maxlen=120, filehandle=sys.stdout): + """Dump all the dictionaries constructed from the Registry object. + + Diagnostic to dump the dictionaries to specified file handle (default stdout). + Truncates type / enum / command elements to maxlen characters (default 120)""" + write('***************************************', file=filehandle) + write(' ** Dumping Registry contents **', file=filehandle) + write('***************************************', file=filehandle) + write('// Types', file=filehandle) + for name in self.typedict: + tobj = self.typedict[name] + write(' Type', name, '->', etree.tostring(tobj.elem)[0:maxlen], file=filehandle) + write('// Groups', file=filehandle) + for name in self.groupdict: + gobj = self.groupdict[name] + write(' Group', name, '->', etree.tostring(gobj.elem)[0:maxlen], file=filehandle) + write('// Enums', file=filehandle) + for name in self.enumdict: + eobj = self.enumdict[name] + write(' Enum', name, '->', etree.tostring(eobj.elem)[0:maxlen], file=filehandle) + write('// Commands', file=filehandle) + for name in self.cmddict: + cobj = self.cmddict[name] + write(' Command', name, '->', etree.tostring(cobj.elem)[0:maxlen], file=filehandle) + write('// APIs', file=filehandle) + for key in self.apidict: + write(' API Version ', key, '->', + etree.tostring(self.apidict[key].elem)[0:maxlen], file=filehandle) + write('// Extensions', file=filehandle) + for key in self.extdict: + write(' Extension', key, '->', + etree.tostring(self.extdict[key].elem)[0:maxlen], file=filehandle) + write('// SPIR-V', file=filehandle) + for key in self.spirvextdict: + write(' SPIR-V Extension', key, '->', + etree.tostring(self.spirvextdict[key].elem)[0:maxlen], file=filehandle) + for key in self.spirvcapdict: + write(' SPIR-V Capability', key, '->', + etree.tostring(self.spirvcapdict[key].elem)[0:maxlen], file=filehandle) + write('// VkFormat', file=filehandle) + for key in self.formatsdict: + write(' VkFormat', key, '->', + etree.tostring(self.formatsdict[key].elem)[0:maxlen], file=filehandle) + + def markTypeRequired(self, typename, required): + """Require (along with its dependencies) or remove (but not its dependencies) a type. + + - typename - name of type + - required - boolean (to tag features as required or not) + """ + self.gen.logMsg('diag', 'tagging type:', typename, '-> required =', required) + + # Get TypeInfo object for tag corresponding to typename + typeinfo = self.lookupElementInfo(typename, self.typedict) + if typeinfo is not None: + if required: + # Tag type dependencies in 'alias' and 'required' attributes as + # required. This does not un-tag dependencies in a + # tag. See comments in markRequired() below for the reason. + for attrib_name in ['requires', 'alias']: + depname = typeinfo.elem.get(attrib_name) + if depname: + self.gen.logMsg('diag', 'Generating dependent type', + depname, 'for', attrib_name, 'type', typename) + # Do not recurse on self-referential structures. + if typename != depname: + self.markTypeRequired(depname, required) + else: + self.gen.logMsg('diag', 'type', typename, 'is self-referential') + # Tag types used in defining this type (e.g. in nested + # tags) + # Look for in entire tree, + # not just immediate children + for subtype in typeinfo.elem.findall('.//type'): + self.gen.logMsg('diag', 'markRequired: type requires dependent ', subtype.text) + if typename != subtype.text: + self.markTypeRequired(subtype.text, required) + else: + self.gen.logMsg('diag', 'type', typename, 'is self-referential') + # Tag enums used in defining this type, for example in + # member[MEMBER_SIZE] + for subenum in typeinfo.elem.findall('.//enum'): + self.gen.logMsg('diag', 'markRequired: type requires dependent ', subenum.text) + self.markEnumRequired(subenum.text, required) + # Tag type dependency in 'bitvalues' attributes as + # required. This ensures that the bit values for a flag + # are emitted + depType = typeinfo.elem.get('bitvalues') + if depType: + self.gen.logMsg('diag', 'Generating bitflag type', + depType, 'for type', typename) + self.markTypeRequired(depType, required) + group = self.lookupElementInfo(depType, self.groupdict) + if group is not None: + group.flagType = typeinfo + + typeinfo.required = required + elif '.h' not in typename: + self.gen.logMsg('warn', 'type:', typename, 'IS NOT DEFINED') + + def markEnumRequired(self, enumname, required): + """Mark an enum as required or not. + + - enumname - name of enum + - required - boolean (to tag features as required or not)""" + + self.gen.logMsg('diag', 'markEnumRequired: tagging enum:', enumname, '-> required =', required) + enum = self.lookupElementInfo(enumname, self.enumdict) + if enum is not None: + # If the enum is part of a group, and is being removed, then + # look it up in that tag and remove the Element there, + # so that it is not visible to generators (which traverse the + # tag elements rather than using the dictionaries). + if not required: + groupName = enum.elem.get('extends') + if groupName is not None: + self.gen.logMsg('diag', f'markEnumRequired: Removing extending enum {enum.elem.get("name")}') + + # Look up the Info with matching groupName + if groupName in self.groupdict: + gi = self.groupdict[groupName] + gienum = gi.elem.find("enum[@name='" + enumname + "']") + if gienum is not None: + # Remove copy of this enum from the group + gi.elem.remove(gienum) + else: + self.gen.logMsg('warn', 'markEnumRequired: Cannot remove enum', + enumname, 'not found in group', + groupName) + else: + self.gen.logMsg('warn', 'markEnumRequired: Cannot remove enum', + enumname, 'from nonexistent group', + groupName) + else: + # This enum is not an extending enum. + # The XML tree must be searched for all that + # might have it, so we know the parent to delete from. + + enumName = enum.elem.get('name') + + self.gen.logMsg('diag', f'markEnumRequired: Removing non-extending enum {enumName}') + + count = 0 + for enums in self.reg.findall('enums'): + for thisEnum in enums.findall('enum'): + if thisEnum.get('name') == enumName: + # Actually remove it + count = count + 1 + enums.remove(thisEnum) + + if count == 0: + self.gen.logMsg('warn', f'markEnumRequired: {enumName}) not found in any tag') + + enum.required = required + # Tag enum dependencies in 'alias' attribute as required + depname = enum.elem.get('alias') + if depname: + self.gen.logMsg('diag', 'markEnumRequired: Generating dependent enum', + depname, 'for alias', enumname, 'required =', enum.required) + self.markEnumRequired(depname, required) + else: + self.gen.logMsg('warn', f'markEnumRequired: {enumname} IS NOT DEFINED') + + def markCmdRequired(self, cmdname, required): + """Mark a command as required or not. + + - cmdname - name of command + - required - boolean (to tag features as required or not)""" + self.gen.logMsg('diag', 'tagging command:', cmdname, '-> required =', required) + cmd = self.lookupElementInfo(cmdname, self.cmddict) + if cmd is not None: + cmd.required = required + + # Tag command dependencies in 'alias' attribute as required + # + # This is usually not done, because command 'aliases' are not + # actual C language aliases like type and enum aliases. Instead + # they are just duplicates of the function signature of the + # alias. This means that there is no dependency of a command + # alias on what it aliases. One exception is validity includes, + # where the spec markup needs the promoted-to validity include + # even if only the promoted-from command is being built. + if self.genOpts.requireCommandAliases: + depname = cmd.elem.get('alias') + if depname: + self.gen.logMsg('diag', 'Generating dependent command', + depname, 'for alias', cmdname) + self.markCmdRequired(depname, required) + + # Tag all parameter types of this command as required. + # This DOES NOT remove types of commands in a + # tag, because many other commands may use the same type. + # We could be more clever and reference count types, + # instead of using a boolean. + if required: + # Look for in entire tree, + # not just immediate children + for type_elem in cmd.elem.findall('.//type'): + self.gen.logMsg('diag', 'markRequired: command implicitly requires dependent type', type_elem.text) + self.markTypeRequired(type_elem.text, required) + else: + self.gen.logMsg('warn', 'command:', cmdname, 'IS NOT DEFINED') + + def markRequired(self, featurename, feature, required): + """Require or remove features specified in the Element. + + - featurename - name of the feature + - feature - Element for `` or `` tag + - required - boolean (to tag features as required or not)""" + self.gen.logMsg('diag', 'markRequired (feature = , required =', required, ')') + + # Loop over types, enums, and commands in the tag + # @@ It would be possible to respect 'api' and 'profile' attributes + # in individual features, but that is not done yet. + for typeElem in feature.findall('type'): + self.markTypeRequired(typeElem.get('name'), required) + for enumElem in feature.findall('enum'): + self.markEnumRequired(enumElem.get('name'), required) + + for cmdElem in feature.findall('command'): + self.markCmdRequired(cmdElem.get('name'), required) + + # Extensions may need to extend existing commands or other items in the future. + # So, look for extend tags. + for extendElem in feature.findall('extend'): + extendType = extendElem.get('type') + if extendType == 'command': + commandName = extendElem.get('name') + successExtends = extendElem.get('successcodes') + if successExtends is not None: + for success in successExtends.split(','): + self.commandextensionsuccesses.append(self.commandextensiontuple(command=commandName, + value=success, + extension=featurename)) + errorExtends = extendElem.get('errorcodes') + if errorExtends is not None: + for error in errorExtends.split(','): + self.commandextensionerrors.append(self.commandextensiontuple(command=commandName, + value=error, + extension=featurename)) + else: + self.gen.logMsg('warn', 'extend type:', extendType, 'IS NOT SUPPORTED') + + def getAlias(self, elem, dict): + """Check for an alias in the same require block. + + - elem - Element to check for an alias""" + + # Try to find an alias + alias = elem.get('alias') + if alias is None: + name = elem.get('name') + typeinfo = self.lookupElementInfo(name, dict) + alias = typeinfo.elem.get('alias') + + return alias + + def checkForCorrectionAliases(self, alias, require, tag): + """Check for an alias in the same require block. + + - alias - String name of the alias + - require - `` block from the registry + - tag - tag to look for in the require block""" + + # For the time being, the code below is bypassed. It has the effect + # of excluding "spelling aliases" created to comply with the style + # guide, but this leaves references out of the specification and + # causes broken internal links. + # + # if alias and require.findall(tag + "[@name='" + alias + "']"): + # return True + + return False + + def fillFeatureDictionary(self, interface, featurename, api, profile): + """Capture added interfaces for a `` or ``. + + - interface - Element for `` or ``, containing + `` and `` tags + - featurename - name of the feature + - api - string specifying API name being generated + - profile - string specifying API profile being generated""" + + # Explicitly initialize known types - errors for unhandled categories + self.gen.featureDictionary[featurename] = { + "enumconstant": {}, + "command": {}, + "enum": {}, + "struct": {}, + "handle": {}, + "basetype": {}, + "include": {}, + "define": {}, + "bitmask": {}, + "union": {}, + "funcpointer": {}, + } + + # marks things that are required by this version/profile + for require in interface.findall('require'): + if matchAPIProfile(api, profile, require): + + # Determine the required extension or version needed for a require block + # Assumes that only one of these is specified + required_key = require.get('feature') + if required_key is None: + required_key = require.get('extension') + + # Loop over types, enums, and commands in the tag + for typeElem in require.findall('type'): + typename = typeElem.get('name') + typeinfo = self.lookupElementInfo(typename, self.typedict) + + if typeinfo: + # Remove aliases in the same extension/feature; these are always added as a correction. Do not need the original to be visible. + alias = self.getAlias(typeElem, self.typedict) + if not self.checkForCorrectionAliases(alias, require, 'type'): + # Resolve the type info to the actual type, so we get an accurate read for 'structextends' + while alias: + typeinfo = self.lookupElementInfo(alias, self.typedict) + alias = typeinfo.elem.get('alias') + + typecat = typeinfo.elem.get('category') + typeextends = typeinfo.elem.get('structextends') + if not required_key in self.gen.featureDictionary[featurename][typecat]: + self.gen.featureDictionary[featurename][typecat][required_key] = {} + if not typeextends in self.gen.featureDictionary[featurename][typecat][required_key]: + self.gen.featureDictionary[featurename][typecat][required_key][typeextends] = [] + self.gen.featureDictionary[featurename][typecat][required_key][typeextends].append(typename) + else: + self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename)) + + + for enumElem in require.findall('enum'): + enumname = enumElem.get('name') + typeinfo = self.lookupElementInfo(enumname, self.enumdict) + + # Remove aliases in the same extension/feature; these are always added as a correction. Do not need the original to be visible. + alias = self.getAlias(enumElem, self.enumdict) + if not self.checkForCorrectionAliases(alias, require, 'enum'): + enumextends = enumElem.get('extends') + if not required_key in self.gen.featureDictionary[featurename]['enumconstant']: + self.gen.featureDictionary[featurename]['enumconstant'][required_key] = {} + if not enumextends in self.gen.featureDictionary[featurename]['enumconstant'][required_key]: + self.gen.featureDictionary[featurename]['enumconstant'][required_key][enumextends] = [] + self.gen.featureDictionary[featurename]['enumconstant'][required_key][enumextends].append(enumname) + else: + self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename)) + + for cmdElem in require.findall('command'): + # Remove aliases in the same extension/feature; these are always added as a correction. Do not need the original to be visible. + alias = self.getAlias(cmdElem, self.cmddict) + if not self.checkForCorrectionAliases(alias, require, 'command'): + if not required_key in self.gen.featureDictionary[featurename]['command']: + self.gen.featureDictionary[featurename]['command'][required_key] = [] + self.gen.featureDictionary[featurename]['command'][required_key].append(cmdElem.get('name')) + else: + self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename)) + + def requireFeatures(self, interface, featurename, api, profile): + """Process `` tags for a `` or ``. + + - interface - Element for `` or ``, containing + `` tags + - featurename - name of the feature + - api - string specifying API name being generated + - profile - string specifying API profile being generated""" + + # marks things that are required by this version/profile + for feature in interface.findall('require'): + if matchAPIProfile(api, profile, feature): + self.markRequired(featurename, feature, True) + + def removeFeatures(self, interface, featurename, api, profile): + """Process `` tags for a `` or ``. + + - interface - Element for `` or ``, containing + `` tags + - featurename - name of the feature + - api - string specifying API name being generated + - profile - string specifying API profile being generated""" + + # marks things that are removed by this version/profile + for feature in interface.findall('remove'): + if matchAPIProfile(api, profile, feature): + self.markRequired(featurename, feature, False) + + def assignAdditionalValidity(self, interface, api, profile): + # Loop over all usage inside all tags. + for feature in interface.findall('require'): + if matchAPIProfile(api, profile, feature): + for v in feature.findall('usage'): + if v.get('command'): + self.cmddict[v.get('command')].additionalValidity.append(copy.deepcopy(v)) + if v.get('struct'): + self.typedict[v.get('struct')].additionalValidity.append(copy.deepcopy(v)) + + def removeAdditionalValidity(self, interface, api, profile): + # Loop over all usage inside all tags. + for feature in interface.findall('remove'): + if matchAPIProfile(api, profile, feature): + for v in feature.findall('usage'): + if v.get('command'): + self.cmddict[v.get('command')].removedValidity.append(copy.deepcopy(v)) + if v.get('struct'): + self.typedict[v.get('struct')].removedValidity.append(copy.deepcopy(v)) + + def generateFeature(self, fname, ftype, dictionary): + """Generate a single type / enum group / enum / command, + and all its dependencies as needed. + + - fname - name of feature (``/``/``) + - ftype - type of feature, 'type' | 'enum' | 'command' + - dictionary - of *Info objects - self.{type|enum|cmd}dict""" + + self.gen.logMsg('diag', 'generateFeature: generating', ftype, fname) + f = self.lookupElementInfo(fname, dictionary) + if f is None: + # No such feature. This is an error, but reported earlier + self.gen.logMsg('diag', 'No entry found for feature', fname, + 'returning!') + return + + # If feature is not required, or has already been declared, return + if not f.required: + self.gen.logMsg('diag', 'Skipping', ftype, fname, '(not required)') + return + if f.declared: + self.gen.logMsg('diag', 'Skipping', ftype, fname, '(already declared)') + return + # Always mark feature declared, as though actually emitted + f.declared = True + + # Determine if this is an alias, and of what, if so + alias = f.elem.get('alias') + if alias: + self.gen.logMsg('diag', fname, 'is an alias of', alias) + + # Pull in dependent declaration(s) of the feature. + # For types, there may be one type in the 'requires' attribute of + # the element, one in the 'alias' attribute, and many in + # embedded and tags within the element. + # For commands, there may be many in tags within the element. + # For enums, no dependencies are allowed (though perhaps if you + # have a uint64 enum, it should require that type). + genProc = None + followupFeature = None + if ftype == 'type': + genProc = self.gen.genType + + # Generate type dependencies in 'alias' and 'requires' attributes + if alias: + self.generateFeature(alias, 'type', self.typedict) + requires = f.elem.get('requires') + if requires: + self.gen.logMsg('diag', 'Generating required dependent type', + requires) + self.generateFeature(requires, 'type', self.typedict) + + # Generate types used in defining this type (e.g. in nested + # tags) + # Look for in entire tree, + # not just immediate children + for subtype in f.elem.findall('.//type'): + self.gen.logMsg('diag', 'Generating required dependent ', + subtype.text) + self.generateFeature(subtype.text, 'type', self.typedict) + + # Generate enums used in defining this type, for example in + # member[MEMBER_SIZE] + for subtype in f.elem.findall('.//enum'): + self.gen.logMsg('diag', 'Generating required dependent ', + subtype.text) + self.generateFeature(subtype.text, 'enum', self.enumdict) + + # If the type is an enum group, look up the corresponding + # group in the group dictionary and generate that instead. + if f.elem.get('category') == 'enum': + self.gen.logMsg('diag', 'Type', fname, 'is an enum group, so generate that instead') + group = self.lookupElementInfo(fname, self.groupdict) + if alias is not None: + # An alias of another group name. + # Pass to genGroup with 'alias' parameter = aliased name + self.gen.logMsg('diag', 'Generating alias', fname, + 'for enumerated type', alias) + # Now, pass the *aliased* GroupInfo to the genGroup, but + # with an additional parameter which is the alias name. + genProc = self.gen.genGroup + f = self.lookupElementInfo(alias, self.groupdict) + elif group is None: + self.gen.logMsg('warn', 'Skipping enum type', fname, + ': No matching enumerant group') + return + else: + genProc = self.gen.genGroup + f = group + + # @ The enum group is not ready for generation. At this + # @ point, it contains all tags injected by + # @ tags without any verification of whether + # @ they are required or not. It may also contain + # @ duplicates injected by multiple consistent + # @ definitions of an . + + # @ Pass over each enum, marking its enumdict[] entry as + # @ required or not. Mark aliases of enums as required, + # @ too. + + enums = group.elem.findall('enum') + + self.gen.logMsg('diag', 'generateFeature: checking enums for group', fname) + + # Check for required enums, including aliases + # LATER - Check for, report, and remove duplicates? + enumAliases = [] + for elem in enums: + name = elem.get('name') + + required = False + + extname = elem.get('extname') + version = elem.get('version') + if extname is not None: + # 'supported' attribute was injected when the element was + # moved into the group in Registry.parseTree() + supported_list = elem.get('supported').split(",") + if self.genOpts.defaultExtensions in supported_list: + required = True + elif re.match(self.genOpts.addExtensions, extname) is not None: + required = True + elif version is not None: + required = re.match(self.genOpts.emitversions, version) is not None + else: + required = True + + self.gen.logMsg('diag', '* required =', required, 'for', name) + if required: + # Mark this element as required (in the element, not the EnumInfo) + elem.set('required', 'true') + # If it is an alias, track that for later use + enumAlias = elem.get('alias') + if enumAlias: + enumAliases.append(enumAlias) + for elem in enums: + name = elem.get('name') + if name in enumAliases: + elem.set('required', 'true') + self.gen.logMsg('diag', '* also need to require alias', name) + if f.elem.get('category') == 'bitmask': + followupFeature = f.elem.get('bitvalues') + elif ftype == 'command': + # Generate command dependencies in 'alias' attribute + if alias: + self.generateFeature(alias, 'command', self.cmddict) + + genProc = self.gen.genCmd + for type_elem in f.elem.findall('.//type'): + depname = type_elem.text + self.gen.logMsg('diag', 'Generating required parameter type', + depname) + self.generateFeature(depname, 'type', self.typedict) + elif ftype == 'enum': + # Generate enum dependencies in 'alias' attribute + if alias: + self.generateFeature(alias, 'enum', self.enumdict) + genProc = self.gen.genEnum + + # Actually generate the type only if emitting declarations + if self.emitFeatures: + self.gen.logMsg('diag', 'Emitting', ftype, 'decl for', fname) + genProc(f, fname, alias) + else: + self.gen.logMsg('diag', 'Skipping', ftype, fname, + '(should not be emitted)') + + if followupFeature: + self.gen.logMsg('diag', 'Generating required bitvalues ', + followupFeature) + self.generateFeature(followupFeature, "type", self.typedict) + + def generateRequiredInterface(self, interface): + """Generate all interfaces required by an API version or extension. + + - interface - Element for `` or ``""" + + # Loop over all features inside all tags. + for features in interface.findall('require'): + for t in features.findall('type'): + self.generateFeature(t.get('name'), 'type', self.typedict) + for e in features.findall('enum'): + # If this is an enum extending an enumerated type, do not + # generate it - this has already been done in reg.parseTree, + # by copying this element into the enumerated type. + enumextends = e.get('extends') + if not enumextends: + self.generateFeature(e.get('name'), 'enum', self.enumdict) + for c in features.findall('command'): + self.generateFeature(c.get('name'), 'command', self.cmddict) + + def generateSpirv(self, spirv, dictionary): + if spirv is None: + self.gen.logMsg('diag', 'No entry found for element', name, + 'returning!') + return + + name = spirv.elem.get('name') + # No known alias for spirv elements + alias = None + if spirv.emit: + genProc = self.gen.genSpirv + genProc(spirv, name, alias) + + def stripUnsupportedAPIs(self, dictionary, attribute, supportedDictionary): + """Strip unsupported APIs from attributes of APIs. + dictionary - *Info dictionary of APIs to be updated + attribute - attribute name to look for in each API + supportedDictionary - dictionary in which to look for supported + API elements in the attribute""" + + for key in dictionary: + eleminfo = dictionary[key] + attribstring = eleminfo.elem.get(attribute) + if attribstring is not None: + apis = [] + stripped = False + for api in attribstring.split(','): + ##print('Checking API {} referenced by {}'.format(api, key)) + if supportedDictionary[api].required: + apis.append(api) + else: + stripped = True + ##print('\t**STRIPPING API {} from {}'.format(api, key)) + + # Update the attribute after stripping stuff. + # Could sort apis before joining, but it is not a clear win + if stripped: + eleminfo.elem.set(attribute, ','.join(apis)) + + def stripUnsupportedAPIsFromList(self, dictionary, supportedDictionary): + """Strip unsupported APIs from attributes of APIs. + dictionary - dictionary of list of structure name strings + supportedDictionary - dictionary in which to look for supported + API elements in the attribute""" + + for key in dictionary: + attribstring = dictionary[key] + if attribstring is not None: + apis = [] + stripped = False + for api in attribstring: + ##print('Checking API {} referenced by {}'.format(api, key)) + if supportedDictionary[api].required: + apis.append(api) + else: + stripped = True + ##print('\t**STRIPPING API {} from {}'.format(api, key)) + + # Update the attribute after stripping stuff. + # Could sort apis before joining, but it is not a clear win + if stripped: + dictionary[key] = apis + + def generateFormat(self, format, dictionary): + if format is None: + self.gen.logMsg('diag', 'No entry found for format element', + 'returning!') + return + + name = format.elem.get('name') + # No known alias for VkFormat elements + alias = None + if format.emit: + genProc = self.gen.genFormat + genProc(format, name, alias) + + def apiGen(self): + """Generate interface for specified versions using the current + generator and generator options""" + + self.gen.logMsg('diag', '*******************************************') + self.gen.logMsg('diag', ' Registry.apiGen file:', self.genOpts.filename, + 'api:', self.genOpts.apiname, + 'profile:', self.genOpts.profile) + self.gen.logMsg('diag', '*******************************************') + + # Could reset required/declared flags for all features here. + # This has been removed as never used. The initial motivation was + # the idea of calling apiGen() repeatedly for different targets, but + # this has never been done. The 20% or so build-time speedup that + # might result is not worth the effort to make it actually work. + # + # self.apiReset() + + # Compile regexps used to select versions & extensions + regVersions = re.compile(self.genOpts.versions) + regEmitVersions = re.compile(self.genOpts.emitversions) + regAddExtensions = re.compile(self.genOpts.addExtensions) + regRemoveExtensions = re.compile(self.genOpts.removeExtensions) + regEmitExtensions = re.compile(self.genOpts.emitExtensions) + regEmitSpirv = re.compile(self.genOpts.emitSpirv) + regEmitFormats = re.compile(self.genOpts.emitFormats) + + # Get all matching API feature names & add to list of FeatureInfo + # Note we used to select on feature version attributes, not names. + features = [] + apiMatch = False + for key in self.apidict: + fi = self.apidict[key] + api = fi.elem.get('api') + if apiNameMatch(self.genOpts.apiname, api): + apiMatch = True + if regVersions.match(fi.name): + # Matches API & version #s being generated. Mark for + # emission and add to the features[] list . + # @@ Could use 'declared' instead of 'emit'? + fi.emit = (regEmitVersions.match(fi.name) is not None) + features.append(fi) + if not fi.emit: + self.gen.logMsg('diag', 'NOT tagging feature api =', api, + 'name =', fi.name, 'version =', fi.version, + 'for emission (does not match emitversions pattern)') + else: + self.gen.logMsg('diag', 'Including feature api =', api, + 'name =', fi.name, 'version =', fi.version, + 'for emission (matches emitversions pattern)') + else: + self.gen.logMsg('diag', 'NOT including feature api =', api, + 'name =', fi.name, 'version =', fi.version, + '(does not match requested versions)') + else: + self.gen.logMsg('diag', 'NOT including feature api =', api, + 'name =', fi.name, + '(does not match requested API)') + if not apiMatch: + self.gen.logMsg('warn', 'No matching API versions found!') + + # Get all matching extensions, in order by their extension number, + # and add to the list of features. + # Start with extensions whose 'supported' attributes match the API + # being generated. Add extensions matching the pattern specified in + # regExtensions, then remove extensions matching the pattern + # specified in regRemoveExtensions + for (extName, ei) in sorted(self.extdict.items(), key=lambda x: x[1].number if x[1].number is not None else '0'): + extName = ei.name + include = False + + # Include extension if defaultExtensions is not None and is + # exactly matched by the 'supported' attribute. + if apiNameMatch(self.genOpts.defaultExtensions, + ei.elem.get('supported')): + self.gen.logMsg('diag', 'Including extension', + extName, "(defaultExtensions matches the 'supported' attribute)") + include = True + + # Include additional extensions if the extension name matches + # the regexp specified in the generator options. This allows + # forcing extensions into an interface even if they are not + # tagged appropriately in the registry. + # However we still respect the 'supported' attribute. + if regAddExtensions.match(extName) is not None: + if not apiNameMatch(self.genOpts.apiname, ei.elem.get('supported')): + self.gen.logMsg('diag', 'NOT including extension', + extName, '(matches explicitly requested, but does not match the \'supported\' attribute)') + include = False + else: + self.gen.logMsg('diag', 'Including extension', + extName, '(matches explicitly requested extensions to add)') + include = True + # Remove extensions if the name matches the regexp specified + # in generator options. This allows forcing removal of + # extensions from an interface even if they are tagged that + # way in the registry. + if regRemoveExtensions.match(extName) is not None: + self.gen.logMsg('diag', 'Removing extension', + extName, '(matches explicitly requested extensions to remove)') + include = False + + # If the extension is to be included, add it to the + # extension features list. + if include: + ei.emit = (regEmitExtensions.match(extName) is not None) + features.append(ei) + if not ei.emit: + self.gen.logMsg('diag', 'NOT tagging extension', + extName, + 'for emission (does not match emitextensions pattern)') + + # Hack - can be removed when validity generator goes away + # (Jon) I am not sure what this does, or if it should + # respect the ei.emit flag above. + self.requiredextensions.append(extName) + else: + self.gen.logMsg('diag', 'NOT including extension', + extName, '(does not match api attribute or explicitly requested extensions)') + + # Add all spirv elements to list + # generators decide to emit them all or not + # Currently no filtering as no client of these elements needs filtering + spirvexts = [] + for key in self.spirvextdict: + si = self.spirvextdict[key] + si.emit = (regEmitSpirv.match(key) is not None) + spirvexts.append(si) + spirvcaps = [] + for key in self.spirvcapdict: + si = self.spirvcapdict[key] + si.emit = (regEmitSpirv.match(key) is not None) + spirvcaps.append(si) + + formats = [] + for key in self.formatsdict: + si = self.formatsdict[key] + si.emit = (regEmitFormats.match(key) is not None) + formats.append(si) + + # Sort the features list, if a sort procedure is defined + if self.genOpts.sortProcedure: + self.genOpts.sortProcedure(features) + # print('sortProcedure ->', [f.name for f in features]) + + # Passes 1+2: loop over requested API versions and extensions tagging + # types/commands/features as required (in an block) or no + # longer required (in an block). s are processed + # after all s, so removals win. + # If a profile other than 'None' is being generated, it must + # match the profile attribute (if any) of the and + # tags. + self.gen.logMsg('diag', 'PASS 1: TAG FEATURES') + for f in features: + self.gen.logMsg('diag', 'PASS 1: Tagging required and features for', f.name) + self.fillFeatureDictionary(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile) + self.requireFeatures(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile) + self.assignAdditionalValidity(f.elem, self.genOpts.apiname, self.genOpts.profile) + + for f in features: + self.gen.logMsg('diag', 'PASS 2: Tagging removed features for', f.name) + self.removeFeatures(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile) + self.removeAdditionalValidity(f.elem, self.genOpts.apiname, self.genOpts.profile) + + # Now, strip references to APIs that are not required. + # At present such references may occur in: + # Structs in 'structextends' attributes + # Enums in 'successcodes' and 'errorcodes' attributes + self.stripUnsupportedAPIs(self.typedict, 'structextends', self.typedict) + self.stripUnsupportedAPIs(self.cmddict, 'successcodes', self.enumdict) + self.stripUnsupportedAPIs(self.cmddict, 'errorcodes', self.enumdict) + self.stripUnsupportedAPIsFromList(self.validextensionstructs, self.typedict) + + # @@May need to strip / + # tags of these forms: + # + # + # + # + + # Pass 3: loop over specified API versions and extensions printing + # declarations for required things which have not already been + # generated. + self.gen.logMsg('diag', 'PASS 3: GENERATE INTERFACES FOR FEATURES') + self.gen.beginFile(self.genOpts) + for f in features: + self.gen.logMsg('diag', 'PASS 3: Generating interface for', + f.name) + emit = self.emitFeatures = f.emit + if not emit: + self.gen.logMsg('diag', 'PASS 3: NOT declaring feature', + f.elem.get('name'), 'because it is not tagged for emission') + # Generate the interface (or just tag its elements as having been + # emitted, if they have not been). + self.gen.beginFeature(f.elem, emit) + self.generateRequiredInterface(f.elem) + self.gen.endFeature() + # Generate spirv elements + for s in spirvexts: + self.generateSpirv(s, self.spirvextdict) + for s in spirvcaps: + self.generateSpirv(s, self.spirvcapdict) + for s in formats: + self.generateFormat(s, self.formatsdict) + self.gen.endFile() + + def apiReset(self): + """Reset type/enum/command dictionaries before generating another API. + + Use between apiGen() calls to reset internal state.""" + for datatype in self.typedict: + self.typedict[datatype].resetState() + for enum in self.enumdict: + self.enumdict[enum].resetState() + for cmd in self.cmddict: + self.cmddict[cmd].resetState() + for cmd in self.apidict: + self.apidict[cmd].resetState() + + def __validateStructLimittypes(self, struct): + """Validate 'limittype' attributes for a single struct.""" + limittypeDiags = namedtuple('limittypeDiags', ['missing', 'invalid']) + badFields = defaultdict(lambda : limittypeDiags(missing=[], invalid=[])) + validLimittypes = { 'min', 'max', 'bitmask', 'range', 'struct', 'noauto' } + for member in struct.getMembers(): + memberName = member.findtext('name') + if memberName in ['sType', 'pNext']: + continue + limittype = member.get('limittype') + if not limittype: + badFields[struct.elem.get('name')].missing.append(memberName) + elif limittype == 'struct': + typeName = member.findtext('type') + memberType = self.typedict[typeName] + badFields.update(self.__validateStructLimittypes(memberType)) + elif limittype not in validLimittypes: + badFields[struct.elem.get('name')].invalid.append(memberName) + return badFields + + def __validateLimittype(self): + """Validate 'limittype' attributes.""" + badFields = self.__validateStructLimittypes(self.typedict['VkPhysicalDeviceProperties2']) + for featStructName in self.validextensionstructs['VkPhysicalDeviceProperties2']: + featStruct = self.typedict[featStructName] + badFields.update(self.__validateStructLimittypes(featStruct)) + + if badFields: + self.gen.logMsg('diag', 'SUMMARY OF FIELDS WITH INCORRECT LIMITTYPES') + for key in sorted(badFields.keys()): + diags = badFields[key] + if diags.missing: + self.gen.logMsg('diag', ' ', key, 'missing limittype:', ', '.join(badFields[key].missing)) + if diags.invalid: + self.gen.logMsg('diag', ' ', key, 'invalid limittype:', ', '.join(badFields[key].invalid)) + return False + return True + + def validateRegistry(self): + """Validate properties of the registry.""" + return self.__validateLimittype() diff --git a/registry/spec_tools/util.py b/registry/spec_tools/util.py new file mode 100644 index 0000000..b890679 --- /dev/null +++ b/registry/spec_tools/util.py @@ -0,0 +1,58 @@ +"""Utility functions not closely tied to other spec_tools types.""" +# Copyright 2018-2019 Collabora, Ltd. +# Copyright 2013-2021 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 + + +def getElemName(elem, default=None): + """Get the name associated with an element, either a name child or name attribute.""" + name_elem = elem.find('name') + if name_elem is not None: + return name_elem.text + # Fallback if there is no child. + return elem.get('name', default) + + +def getElemType(elem, default=None): + """Get the type associated with an element, either a type child or type attribute.""" + type_elem = elem.find('type') + if type_elem is not None: + return type_elem.text + # Fallback if there is no child. + return elem.get('type', default) + + +def findFirstWithPredicate(collection, pred): + """Return the first element that satisfies the predicate, or None if none exist. + + NOTE: Some places where this is used might be better served by changing to a dictionary. + """ + for elt in collection: + if pred(elt): + return elt + return None + + +def findNamedElem(elems, name): + """Traverse a collection of elements with 'name' nodes or attributes, looking for and returning one with the right name. + + NOTE: Many places where this is used might be better served by changing to a dictionary. + """ + return findFirstWithPredicate(elems, lambda elem: getElemName(elem) == name) + + +def findTypedElem(elems, typename): + """Traverse a collection of elements with 'type' nodes or attributes, looking for and returning one with the right typename. + + NOTE: Many places where this is used might be better served by changing to a dictionary. + """ + return findFirstWithPredicate(elems, lambda elem: getElemType(elem) == typename) + + +def findNamedObject(collection, name): + """Traverse a collection of elements with 'name' attributes, looking for and returning one with the right name. + + NOTE: Many places where this is used might be better served by changing to a dictionary. + """ + return findFirstWithPredicate(collection, lambda elt: elt.name == name) diff --git a/registry/validusage.json b/registry/validusage.json new file mode 100644 index 0000000..7244a30 --- /dev/null +++ b/registry/validusage.json @@ -0,0 +1,41218 @@ +{ + "version info": { + "schema version": 2, + "api version": "1.0.9", + "comment": "from git branch: github-sc_main commit: 0fd144fc0aca908f42b8dee88080ba70d030a631", + "date": "2022-02-25 11:47:15Z" + }, + "validation": { + "vkGetInstanceProcAddr": { + "core": [ + { + "vuid": "VUID-vkGetInstanceProcAddr-instance-parameter", + "text": " If instance is not NULL, instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkGetInstanceProcAddr-pName-parameter", + "text": " pName must be a null-terminated UTF-8 string" + } + ] + }, + "vkGetDeviceProcAddr": { + "core": [ + { + "vuid": "VUID-vkGetDeviceProcAddr-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetDeviceProcAddr-pName-parameter", + "text": " pName must be a null-terminated UTF-8 string" + } + ] + }, + "vkEnumerateInstanceVersion": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkEnumerateInstanceVersion-pApiVersion-parameter", + "text": " pApiVersion must be a valid pointer to a uint32_t value" + } + ] + }, + "vkCreateInstance": { + "core": [ + { + "vuid": "VUID-vkCreateInstance-ppEnabledExtensionNames-01388", + "text": " All required extensions for each extension in the VkInstanceCreateInfo::ppEnabledExtensionNames list must also be present in that list" + }, + { + "vuid": "VUID-vkCreateInstance-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkInstanceCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateInstance-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateInstance-pInstance-parameter", + "text": " pInstance must be a valid pointer to a VkInstance handle" + } + ] + }, + "VkInstanceCreateInfo": { + "(VK_EXT_debug_report,VK_EXT_debug_utils)+(VK_EXT_debug_report)": [ + { + "vuid": "VUID-VkInstanceCreateInfo-pNext-04925", + "text": " If the pNext chain of VkInstanceCreateInfo includes a VkDebugReportCallbackCreateInfoEXT structure, the list of enabled extensions in ppEnabledExtensionNames must contain VK_EXT_debug_report" + } + ], + "(VK_EXT_debug_report,VK_EXT_debug_utils)+(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-VkInstanceCreateInfo-pNext-04926", + "text": " If the pNext chain of VkInstanceCreateInfo includes a VkDebugUtilsMessengerCreateInfoEXT structure, the list of enabled extensions in ppEnabledExtensionNames must contain VK_EXT_debug_utils" + } + ], + "core": [ + { + "vuid": "VUID-VkInstanceCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO" + }, + { + "vuid": "VUID-VkInstanceCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDebugUtilsMessengerCreateInfoEXT or VkValidationFeaturesEXT" + }, + { + "vuid": "VUID-VkInstanceCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique, with the exception of structures of type VkDebugUtilsMessengerCreateInfoEXT" + }, + { + "vuid": "VUID-VkInstanceCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkInstanceCreateInfo-pApplicationInfo-parameter", + "text": " If pApplicationInfo is not NULL, pApplicationInfo must be a valid pointer to a valid VkApplicationInfo structure" + }, + { + "vuid": "VUID-VkInstanceCreateInfo-ppEnabledLayerNames-parameter", + "text": " If enabledLayerCount is not 0, ppEnabledLayerNames must be a valid pointer to an array of enabledLayerCount null-terminated UTF-8 strings" + }, + { + "vuid": "VUID-VkInstanceCreateInfo-ppEnabledExtensionNames-parameter", + "text": " If enabledExtensionCount is not 0, ppEnabledExtensionNames must be a valid pointer to an array of enabledExtensionCount null-terminated UTF-8 strings" + } + ] + }, + "VkValidationFeaturesEXT": { + "(VK_EXT_validation_features)": [ + { + "vuid": "VUID-VkValidationFeaturesEXT-pEnabledValidationFeatures-02967", + "text": " If the pEnabledValidationFeatures array contains VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT, then it must also contain VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT" + }, + { + "vuid": "VUID-VkValidationFeaturesEXT-pEnabledValidationFeatures-02968", + "text": " If the pEnabledValidationFeatures array contains VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT, then it must not contain VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT" + }, + { + "vuid": "VUID-VkValidationFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT" + }, + { + "vuid": "VUID-VkValidationFeaturesEXT-pEnabledValidationFeatures-parameter", + "text": " If enabledValidationFeatureCount is not 0, pEnabledValidationFeatures must be a valid pointer to an array of enabledValidationFeatureCount valid VkValidationFeatureEnableEXT values" + }, + { + "vuid": "VUID-VkValidationFeaturesEXT-pDisabledValidationFeatures-parameter", + "text": " If disabledValidationFeatureCount is not 0, pDisabledValidationFeatures must be a valid pointer to an array of disabledValidationFeatureCount valid VkValidationFeatureDisableEXT values" + } + ] + }, + "VkApplicationInfo": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkApplicationInfo-apiVersion-04010", + "text": " If apiVersion is not 0, then it must be greater than or equal to VK_API_VERSION_1_0" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkApplicationInfo-apiVersion-05021", + "text": " If apiVersion is not 0, then it must be greater than or equal to VKSC_API_VERSION_1_0" + } + ], + "(VK_EXT_application_parameters)": [ + { + "vuid": "VUID-VkApplicationInfo-key-05093", + "text": " The key value of each VkApplicationParametersEXT structure in the VkApplicationInfo::pNext chain must be unique for each vendorID and deviceID pairing" + } + ], + "core": [ + { + "vuid": "VUID-VkApplicationInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_APPLICATION_INFO" + }, + { + "vuid": "VUID-VkApplicationInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkApplicationParametersEXT" + }, + { + "vuid": "VUID-VkApplicationInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique, with the exception of structures of type VkApplicationParametersEXT" + }, + { + "vuid": "VUID-VkApplicationInfo-pApplicationName-parameter", + "text": " If pApplicationName is not NULL, pApplicationName must be a null-terminated UTF-8 string" + }, + { + "vuid": "VUID-VkApplicationInfo-pEngineName-parameter", + "text": " If pEngineName is not NULL, pEngineName must be a null-terminated UTF-8 string" + } + ] + }, + "VkApplicationParametersEXT": { + "(VK_EXT_application_parameters)": [ + { + "vuid": "VUID-VkApplicationParametersEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT" + } + ] + }, + "vkDestroyInstance": { + "core": [ + { + "vuid": "VUID-vkDestroyInstance-instance-00629", + "text": " All child objects created using instance must have been destroyed prior to destroying instance" + }, + { + "vuid": "VUID-vkDestroyInstance-instance-parameter", + "text": " If instance is not NULL, instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkDestroyInstance-pAllocator-null", + "text": " pAllocator must be NULL" + } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyInstance-instance-00630", + "text": " If VkAllocationCallbacks were provided when instance was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyInstance-instance-00631", + "text": " If no VkAllocationCallbacks were provided when instance was created, pAllocator must be NULL" + } + ] + }, + "vkEnumeratePhysicalDevices": { + "core": [ + { + "vuid": "VUID-vkEnumeratePhysicalDevices-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkEnumeratePhysicalDevices-pPhysicalDeviceCount-parameter", + "text": " pPhysicalDeviceCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkEnumeratePhysicalDevices-pPhysicalDevices-parameter", + "text": " If the value referenced by pPhysicalDeviceCount is not 0, and pPhysicalDevices is not NULL, pPhysicalDevices must be a valid pointer to an array of pPhysicalDeviceCount VkPhysicalDevice handles" + } + ] + }, + "vkGetPhysicalDeviceProperties": { + "core": [ + { + "vuid": "VUID-vkGetPhysicalDeviceProperties-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceProperties-pProperties-parameter", + "text": " pProperties must be a valid pointer to a VkPhysicalDeviceProperties structure" + } + ] + }, + "vkGetPhysicalDeviceProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceProperties2-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceProperties2-pProperties-parameter", + "text": " pProperties must be a valid pointer to a VkPhysicalDeviceProperties2 structure" + } + ] + }, + "VkPhysicalDeviceProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkPhysicalDeviceProperties2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2" + }, + { + "vuid": "VUID-VkPhysicalDeviceProperties2-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceCustomBorderColorPropertiesEXT, VkPhysicalDeviceDepthStencilResolveProperties, VkPhysicalDeviceDescriptorIndexingProperties, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceDriverProperties, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceFloatControlsProperties, VkPhysicalDeviceFragmentShadingRatePropertiesKHR, VkPhysicalDeviceIDProperties, VkPhysicalDeviceLineRasterizationPropertiesEXT, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMultiviewProperties, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePerformanceQueryPropertiesKHR, VkPhysicalDevicePointClippingProperties, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDeviceRobustness2PropertiesEXT, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxProperties, VkPhysicalDeviceSubgroupProperties, VkPhysicalDeviceSubgroupSizeControlPropertiesEXT, VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT, VkPhysicalDeviceTimelineSemaphoreProperties, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT, VkPhysicalDeviceVulkan11Properties, VkPhysicalDeviceVulkan12Properties, or VkPhysicalDeviceVulkanSC10Properties" + }, + { + "vuid": "VUID-VkPhysicalDeviceProperties2-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + } + ] + }, + "VkPhysicalDeviceVulkan11Properties": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_VERSION_1_2)": [ + { + "vuid": "VUID-VkPhysicalDeviceVulkan11Properties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES" + } + ] + }, + "VkPhysicalDeviceVulkan12Properties": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_VERSION_1_2)": [ + { + "vuid": "VUID-VkPhysicalDeviceVulkan12Properties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES" + } + ] + }, + "VkPhysicalDeviceVulkanSC10Properties": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkPhysicalDeviceVulkanSC10Properties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES" + } + ] + }, + "VkPhysicalDeviceIDProperties": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_VERSION_1_1,VK_KHR_external_memory_capabilities,VK_KHR_external_semaphore_capabilities,VK_KHR_external_fence_capabilities)": [ + { + "vuid": "VUID-VkPhysicalDeviceIDProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES" + } + ] + }, + "VkPhysicalDeviceDriverProperties": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_VERSION_1_2,VK_KHR_driver_properties)": [ + { + "vuid": "VUID-VkPhysicalDeviceDriverProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES" + } + ] + }, + "VkPhysicalDevicePCIBusInfoPropertiesEXT": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_EXT_pci_bus_info)": [ + { + "vuid": "VUID-VkPhysicalDevicePCIBusInfoPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT" + } + ] + }, + "vkGetPhysicalDeviceQueueFamilyProperties": { + "core": [ + { + "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyProperties-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyProperties-pQueueFamilyPropertyCount-parameter", + "text": " pQueueFamilyPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyProperties-pQueueFamilyProperties-parameter", + "text": " If the value referenced by pQueueFamilyPropertyCount is not 0, and pQueueFamilyProperties is not NULL, pQueueFamilyProperties must be a valid pointer to an array of pQueueFamilyPropertyCount VkQueueFamilyProperties structures" + } + ] + }, + "vkGetPhysicalDeviceQueueFamilyProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyProperties2-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyProperties2-pQueueFamilyPropertyCount-parameter", + "text": " pQueueFamilyPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyProperties2-pQueueFamilyProperties-parameter", + "text": " If the value referenced by pQueueFamilyPropertyCount is not 0, and pQueueFamilyProperties is not NULL, pQueueFamilyProperties must be a valid pointer to an array of pQueueFamilyPropertyCount VkQueueFamilyProperties2 structures" + } + ] + }, + "VkQueueFamilyProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkQueueFamilyProperties2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2" + }, + { + "vuid": "VUID-VkQueueFamilyProperties2-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkQueueFamilyCheckpointProperties2NV" + }, + { + "vuid": "VUID-VkQueueFamilyProperties2-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + } + ] + }, + "VkQueueFamilyCheckpointProperties2NV": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_NV_device_diagnostic_checkpoints)+(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-VkQueueFamilyCheckpointProperties2NV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV" + } + ] + }, + "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR-pCounterCount-parameter", + "text": " pCounterCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR-pCounters-parameter", + "text": " If the value referenced by pCounterCount is not 0, and pCounters is not NULL, pCounters must be a valid pointer to an array of pCounterCount VkPerformanceCounterKHR structures" + }, + { + "vuid": "VUID-vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR-pCounterDescriptions-parameter", + "text": " If the value referenced by pCounterCount is not 0, and pCounterDescriptions is not NULL, pCounterDescriptions must be a valid pointer to an array of pCounterCount VkPerformanceCounterDescriptionKHR structures" + } + ] + }, + "VkPerformanceCounterKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-VkPerformanceCounterKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR" + }, + { + "vuid": "VUID-VkPerformanceCounterKHR-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "VkPerformanceCounterDescriptionKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-VkPerformanceCounterDescriptionKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR" + }, + { + "vuid": "VUID-VkPerformanceCounterDescriptionKHR-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkEnumeratePhysicalDeviceGroups": { + "(VK_VERSION_1_1,VK_KHR_device_group_creation)": [ + { + "vuid": "VUID-vkEnumeratePhysicalDeviceGroups-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkEnumeratePhysicalDeviceGroups-pPhysicalDeviceGroupCount-parameter", + "text": " pPhysicalDeviceGroupCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkEnumeratePhysicalDeviceGroups-pPhysicalDeviceGroupProperties-parameter", + "text": " If the value referenced by pPhysicalDeviceGroupCount is not 0, and pPhysicalDeviceGroupProperties is not NULL, pPhysicalDeviceGroupProperties must be a valid pointer to an array of pPhysicalDeviceGroupCount VkPhysicalDeviceGroupProperties structures" + } + ] + }, + "VkPhysicalDeviceGroupProperties": { + "(VK_VERSION_1_1,VK_KHR_device_group_creation)": [ + { + "vuid": "VUID-VkPhysicalDeviceGroupProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES" + }, + { + "vuid": "VUID-VkPhysicalDeviceGroupProperties-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkCreateDevice": { + "core": [ + { + "vuid": "VUID-vkCreateDevice-ppEnabledExtensionNames-01387", + "text": " All required device extensions for each extension in the VkDeviceCreateInfo::ppEnabledExtensionNames list must also be present in that list" + }, + { + "vuid": "VUID-vkCreateDevice-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkCreateDevice-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkDeviceCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateDevice-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateDevice-pDevice-parameter", + "text": " pDevice must be a valid pointer to a VkDevice handle" + } + ], + "(VK_EXT_application_parameters)": [ + { + "vuid": "VUID-vkCreateDevice-key-05092", + "text": " The key value of each VkApplicationParametersEXT structure in the VkDeviceCreateInfo::pNext chain must be unique" + } + ] + }, + "VkDeviceCreateInfo": { + "!(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-queueFamilyIndex-00372", + "text": " The queueFamilyIndex member of each element of pQueueCreateInfos must be unique within pQueueCreateInfos" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-queueFamilyIndex-02802", + "text": " The queueFamilyIndex member of each element of pQueueCreateInfos must be unique within pQueueCreateInfos, except that two members can share the same queueFamilyIndex if one is a protected-capable queue and one is not a protected-capable queue" + } + ], + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-pNext-00373", + "text": " If the pNext chain includes a VkPhysicalDeviceFeatures2 structure, then pEnabledFeatures must be NULL" + } + ], + "(VK_AMD_negative_viewport_height)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-01840", + "text": " ppEnabledExtensionNames must not contain VK_AMD_negative_viewport_height" + } + ], + "(VK_AMD_negative_viewport_height)+!(VK_VERSION_1_1)+(VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-00374", + "text": " ppEnabledExtensionNames must not contain both VK_KHR_maintenance1 and VK_AMD_negative_viewport_height" + } + ], + "(VK_EXT_buffer_device_address+VK_KHR_buffer_device_address)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-03328", + "text": " ppEnabledExtensionNames must not contain both VK_KHR_buffer_device_address and VK_EXT_buffer_device_address" + } + ], + "(VK_VERSION_1_2)+(VK_EXT_buffer_device_address)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-pNext-04748", + "text": " if the pNext chain includes a VkPhysicalDeviceVulkan12Features structure and VkPhysicalDeviceVulkan12Features::bufferDeviceAddress is VK_TRUE, ppEnabledExtensionNames must not contain VK_EXT_buffer_device_address" + } + ], + "(VK_VERSION_1_2)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-pNext-02829", + "text": " If the pNext chain includes a VkPhysicalDeviceVulkan11Features structure, then it must not include a VkPhysicalDevice16BitStorageFeatures, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceSamplerYcbcrConversionFeatures, or VkPhysicalDeviceShaderDrawParametersFeatures structure" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-pNext-02830", + "text": " If the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then it must not include a VkPhysicalDevice8BitStorageFeatures, VkPhysicalDeviceShaderAtomicInt64Features, VkPhysicalDeviceShaderFloat16Int8Features, VkPhysicalDeviceDescriptorIndexingFeatures, VkPhysicalDeviceScalarBlockLayoutFeatures, VkPhysicalDeviceImagelessFramebufferFeatures, VkPhysicalDeviceUniformBufferStandardLayoutFeatures, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, VkPhysicalDeviceHostQueryResetFeatures, VkPhysicalDeviceTimelineSemaphoreFeatures, VkPhysicalDeviceBufferDeviceAddressFeatures, or VkPhysicalDeviceVulkanMemoryModelFeatures structure" + } + ], + "(VK_VERSION_1_2)+(VK_KHR_shader_draw_parameters)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensions-04476", + "text": " If ppEnabledExtensions contains \"VK_KHR_shader_draw_parameters\" and the pNext chain includes a VkPhysicalDeviceVulkan11Features structure, then VkPhysicalDeviceVulkan11Features::shaderDrawParameters must be VK_TRUE" + } + ], + "(VK_VERSION_1_2)+(VK_KHR_draw_indirect_count)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensions-02831", + "text": " If ppEnabledExtensions contains \"VK_KHR_draw_indirect_count\" and the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then VkPhysicalDeviceVulkan12Features::drawIndirectCount must be VK_TRUE" + } + ], + "(VK_VERSION_1_2)+(VK_KHR_sampler_mirror_clamp_to_edge)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensions-02832", + "text": " If ppEnabledExtensions contains \"VK_KHR_sampler_mirror_clamp_to_edge\" and the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then VkPhysicalDeviceVulkan12Features::samplerMirrorClampToEdge must be VK_TRUE" + } + ], + "(VK_VERSION_1_2)+(VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensions-02833", + "text": " If ppEnabledExtensions contains \"VK_EXT_descriptor_indexing\" and the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then VkPhysicalDeviceVulkan12Features::descriptorIndexing must be VK_TRUE" + } + ], + "(VK_VERSION_1_2)+(VK_EXT_sampler_filter_minmax)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensions-02834", + "text": " If ppEnabledExtensions contains \"VK_EXT_sampler_filter_minmax\" and the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then VkPhysicalDeviceVulkan12Features::samplerFilterMinmax must be VK_TRUE" + } + ], + "(VK_VERSION_1_2)+(VK_EXT_shader_viewport_index_layer)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensions-02835", + "text": " If ppEnabledExtensions contains \"VK_EXT_shader_viewport_index_layer\" and the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then VkPhysicalDeviceVulkan12Features::shaderOutputViewportIndex and VkPhysicalDeviceVulkan12Features::shaderOutputLayer must both be VK_TRUE" + } + ], + "(VK_KHR_portability_subset)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-pProperties-04451", + "text": " If the VK_KHR_portability_subset extension is included in pProperties of vkEnumerateDeviceExtensionProperties, ppEnabledExtensions must include \"VK_KHR_portability_subset\"" + } + ], + "(VK_KHR_fragment_shading_rate,VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-shadingRateImage-04478", + "text": " If shadingRateImage is enabled, pipelineFragmentShadingRate must not be enabled" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-shadingRateImage-04479", + "text": " If shadingRateImage is enabled, primitiveFragmentShadingRate must not be enabled" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-shadingRateImage-04480", + "text": " If shadingRateImage is enabled, attachmentFragmentShadingRate must not be enabled" + } + ], + "(VK_KHR_fragment_shading_rate,VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-fragmentDensityMap-04481", + "text": " If fragmentDensityMap is enabled, pipelineFragmentShadingRate must not be enabled" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-fragmentDensityMap-04482", + "text": " If fragmentDensityMap is enabled, primitiveFragmentShadingRate must not be enabled" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-fragmentDensityMap-04483", + "text": " If fragmentDensityMap is enabled, attachmentFragmentShadingRate must not be enabled" + } + ], + "(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-None-04896", + "text": " If sparseImageInt64Atomics is enabled, shaderImageInt64Atomics must be enabled" + } + ], + "(VK_EXT_shader_atomic_float)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-None-04897", + "text": " If sparseImageFloat32Atomics is enabled, shaderImageFloat32Atomics must be enabled" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-None-04898", + "text": " If sparseImageFloat32AtomicAdd is enabled, shaderImageFloat32AtomicAdd must be enabled" + } + ], + "(VK_EXT_shader_atomic_float2)": [ + { + "vuid": "VUID-VkDeviceCreateInfo-sparseImageFloat32AtomicMinMax-04975", + "text": " If sparseImageFloat32AtomicMinMax is enabled, shaderImageFloat32AtomicMinMax must be enabled" + } + ], + "core": [ + { + "vuid": "VUID-VkDeviceCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkApplicationParametersEXT, VkDeviceGroupDeviceCreateInfo, VkDeviceObjectReservationCreateInfo, VkFaultCallbackInfo, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice4444FormatsFeaturesEXT, VkPhysicalDevice8BitStorageFeatures, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceBufferDeviceAddressFeatures, VkPhysicalDeviceColorWriteEnableFeaturesEXT, VkPhysicalDeviceCustomBorderColorFeaturesEXT, VkPhysicalDeviceDepthClipEnableFeaturesEXT, VkPhysicalDeviceDescriptorIndexingFeatures, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, VkPhysicalDeviceFragmentShadingRateFeaturesKHR, VkPhysicalDeviceHostQueryResetFeatures, VkPhysicalDeviceImageRobustnessFeaturesEXT, VkPhysicalDeviceImagelessFramebufferFeatures, VkPhysicalDeviceIndexTypeUint8FeaturesEXT, VkPhysicalDeviceLineRasterizationFeaturesEXT, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDevicePerformanceQueryFeaturesKHR, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceRobustness2FeaturesEXT, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceScalarBlockLayoutFeatures, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT, VkPhysicalDeviceShaderAtomicInt64Features, VkPhysicalDeviceShaderClockFeaturesKHR, VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, VkPhysicalDeviceShaderDrawParametersFeatures, VkPhysicalDeviceShaderFloat16Int8Features, VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT, VkPhysicalDeviceSynchronization2FeaturesKHR, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT, VkPhysicalDeviceTimelineSemaphoreFeatures, VkPhysicalDeviceUniformBufferStandardLayoutFeatures, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT, VkPhysicalDeviceVulkan11Features, VkPhysicalDeviceVulkan12Features, VkPhysicalDeviceVulkanMemoryModelFeatures, VkPhysicalDeviceVulkanSC10Features, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, or VkPhysicalDeviceYcbcrImageArraysFeaturesEXT" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique, with the exception of structures of type VkApplicationParametersEXT or VkDeviceObjectReservationCreateInfo" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-pQueueCreateInfos-parameter", + "text": " pQueueCreateInfos must be a valid pointer to an array of queueCreateInfoCount valid VkDeviceQueueCreateInfo structures" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-ppEnabledLayerNames-parameter", + "text": " If enabledLayerCount is not 0, ppEnabledLayerNames must be a valid pointer to an array of enabledLayerCount null-terminated UTF-8 strings" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-parameter", + "text": " If enabledExtensionCount is not 0, ppEnabledExtensionNames must be a valid pointer to an array of enabledExtensionCount null-terminated UTF-8 strings" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-pEnabledFeatures-parameter", + "text": " If pEnabledFeatures is not NULL, pEnabledFeatures must be a valid pointer to a valid VkPhysicalDeviceFeatures structure" + }, + { + "vuid": "VUID-VkDeviceCreateInfo-queueCreateInfoCount-arraylength", + "text": " queueCreateInfoCount must be greater than 0" + } + ] + }, + "VkDeviceGroupDeviceCreateInfo": { + "(VK_VERSION_1_1,VK_KHR_device_group_creation)": [ + { + "vuid": "VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-00375", + "text": " Each element of pPhysicalDevices must be unique" + }, + { + "vuid": "VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-00376", + "text": " All elements of pPhysicalDevices must be in the same device group as enumerated by vkEnumeratePhysicalDeviceGroups" + }, + { + "vuid": "VUID-VkDeviceGroupDeviceCreateInfo-physicalDeviceCount-00377", + "text": " If physicalDeviceCount is not 0, the physicalDevice parameter of vkCreateDevice must be an element of pPhysicalDevices" + }, + { + "vuid": "VUID-VkDeviceGroupDeviceCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO" + }, + { + "vuid": "VUID-VkDeviceGroupDeviceCreateInfo-pPhysicalDevices-parameter", + "text": " If physicalDeviceCount is not 0, pPhysicalDevices must be a valid pointer to an array of physicalDeviceCount valid VkPhysicalDevice handles" + } + ] + }, + "VkDeviceObjectReservationCreateInfo": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkDeviceObjectReservationCreateInfo-maxImageViewArrayLayers-05014", + "text": " maxImageViewArrayLayers must be less than or equal to VkPhysicalDeviceLimits::maxImageArrayLayers" + }, + { + "vuid": "VUID-VkDeviceObjectReservationCreateInfo-maxImageViewMipLevels-05015", + "text": " maxImageViewMipLevels must be less than or equal to the number of levels in the complete mipmap chain based on the maximum of VkPhysicalDeviceLimits::maxImageDimension1D, maxImageDimension2D, maxImageDimension3D, and maxImageDimensionCube" + }, + { + "vuid": "VUID-VkDeviceObjectReservationCreateInfo-maxLayeredImageViewMipLevels-05016", + "text": " maxLayeredImageViewMipLevels must be less than or equal to the number of levels in the complete mipmap chain based on VkPhysicalDeviceLimits::maxImageDimension1D, maxImageDimension2D, maxImageDimension3D, and maxImageDimensionCube" + }, + { + "vuid": "VUID-VkDeviceObjectReservationCreateInfo-subpassDescriptionRequestCount-05017", + "text": " subpassDescriptionRequestCount must be less than or equal to renderPassRequestCount multiplied by VkPhysicalDeviceVulkanSC10Properties::maxRenderPassSubpasses" + }, + { + "vuid": "VUID-VkDeviceObjectReservationCreateInfo-attachmentDescriptionRequestCount-05018", + "text": " attachmentDescriptionRequestCount must be less than or equal to renderPassRequestCount multiplied by VkPhysicalDeviceVulkanSC10Properties::maxFramebufferAttachments" + }, + { + "vuid": "VUID-VkDeviceObjectReservationCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO" + }, + { + "vuid": "VUID-VkDeviceObjectReservationCreateInfo-pPipelineCacheCreateInfos-parameter", + "text": " If pipelineCacheCreateInfoCount is not 0, pPipelineCacheCreateInfos must be a valid pointer to an array of pipelineCacheCreateInfoCount valid VkPipelineCacheCreateInfo structures" + }, + { + "vuid": "VUID-VkDeviceObjectReservationCreateInfo-pPipelinePoolSizes-parameter", + "text": " If pipelinePoolSizeCount is not 0, pPipelinePoolSizes must be a valid pointer to an array of pipelinePoolSizeCount valid VkPipelinePoolSize structures" + } + ] + }, + "VkPerformanceQueryReservationInfoKHR": { + "(VKSC_VERSION_1_0)+(VK_KHR_performance_query)": [ + { + "vuid": "VUID-VkPerformanceQueryReservationInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR" + } + ] + }, + "VkPipelinePoolSize": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkPipelinePoolSize-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE" + }, + { + "vuid": "VUID-VkPipelinePoolSize-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkDestroyDevice": { + "core": [ + { + "vuid": "VUID-vkDestroyDevice-device-00378", + "text": " All child objects created on device must have been destroyed prior to destroying device" + }, + { + "vuid": "VUID-vkDestroyDevice-device-parameter", + "text": " If device is not NULL, device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyDevice-pAllocator-null", + "text": " pAllocator must be NULL" + } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyDevice-device-00379", + "text": " If VkAllocationCallbacks were provided when device was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyDevice-device-00380", + "text": " If no VkAllocationCallbacks were provided when device was created, pAllocator must be NULL" + } + ] + }, + "VkDeviceQueueCreateInfo": { + "core": [ + { + "vuid": "VUID-VkDeviceQueueCreateInfo-queueFamilyIndex-00381", + "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties" + }, + { + "vuid": "VUID-VkDeviceQueueCreateInfo-queueCount-00382", + "text": " queueCount must be less than or equal to the queueCount member of the VkQueueFamilyProperties structure, as returned by vkGetPhysicalDeviceQueueFamilyProperties in the pQueueFamilyProperties[queueFamilyIndex]" + }, + { + "vuid": "VUID-VkDeviceQueueCreateInfo-pQueuePriorities-00383", + "text": " Each element of pQueuePriorities must be between 0.0 and 1.0 inclusive" + }, + { + "vuid": "VUID-VkDeviceQueueCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO" + }, + { + "vuid": "VUID-VkDeviceQueueCreateInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkDeviceQueueGlobalPriorityCreateInfoEXT" + }, + { + "vuid": "VUID-VkDeviceQueueCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkDeviceQueueCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkDeviceQueueCreateFlagBits values" + }, + { + "vuid": "VUID-VkDeviceQueueCreateInfo-pQueuePriorities-parameter", + "text": " pQueuePriorities must be a valid pointer to an array of queueCount float values" + }, + { + "vuid": "VUID-VkDeviceQueueCreateInfo-queueCount-arraylength", + "text": " queueCount must be greater than 0" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkDeviceQueueCreateInfo-flags-02861", + "text": " If the protected memory feature is not enabled, the VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT bit of flags must not be set" + }, + { + "vuid": "VUID-VkDeviceQueueCreateInfo-flags-06449", + "text": " If flags includes VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT, queueFamilyIndex must be the index of a queue family that includes the VK_QUEUE_PROTECTED_BIT capability" + } + ] + }, + "VkDeviceQueueGlobalPriorityCreateInfoEXT": { + "(VK_EXT_global_priority)": [ + { + "vuid": "VUID-VkDeviceQueueGlobalPriorityCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkDeviceQueueGlobalPriorityCreateInfoEXT-globalPriority-parameter", + "text": " globalPriority must be a valid VkQueueGlobalPriorityEXT value" + } + ] + }, + "vkGetDeviceQueue": { + "core": [ + { + "vuid": "VUID-vkGetDeviceQueue-queueFamilyIndex-00384", + "text": " queueFamilyIndex must be one of the queue family indices specified when device was created, via the VkDeviceQueueCreateInfo structure" + }, + { + "vuid": "VUID-vkGetDeviceQueue-queueIndex-00385", + "text": " queueIndex must be less than the value of VkDeviceQueueCreateInfo::queueCount for the queue family indicated by queueFamilyIndex when device was created" + }, + { + "vuid": "VUID-vkGetDeviceQueue-flags-01841", + "text": " VkDeviceQueueCreateInfo::flags must have been set to zero when device was created" + }, + { + "vuid": "VUID-vkGetDeviceQueue-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetDeviceQueue-pQueue-parameter", + "text": " pQueue must be a valid pointer to a VkQueue handle" + } + ] + }, + "vkGetDeviceQueue2": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkGetDeviceQueue2-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetDeviceQueue2-pQueueInfo-parameter", + "text": " pQueueInfo must be a valid pointer to a valid VkDeviceQueueInfo2 structure" + }, + { + "vuid": "VUID-vkGetDeviceQueue2-pQueue-parameter", + "text": " pQueue must be a valid pointer to a VkQueue handle" + } + ] + }, + "VkDeviceQueueInfo2": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkDeviceQueueInfo2-queueFamilyIndex-01842", + "text": " queueFamilyIndex must be one of the queue family indices specified when device was created, via the VkDeviceQueueCreateInfo structure" + }, + { + "vuid": "VUID-VkDeviceQueueInfo2-flags-06225", + "text": " flags must be equal to VkDeviceQueueCreateInfo::flags for a VkDeviceQueueCreateInfo structure for the queue family indicated by queueFamilyIndex when device was created" + }, + { + "vuid": "VUID-VkDeviceQueueInfo2-queueIndex-01843", + "text": " queueIndex must be less than VkDeviceQueueCreateInfo::queueCount for the corresponding queue family and flags indicated by queueFamilyIndex and flags when device was created" + }, + { + "vuid": "VUID-VkDeviceQueueInfo2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2" + }, + { + "vuid": "VUID-VkDeviceQueueInfo2-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDeviceQueueInfo2-flags-parameter", + "text": " flags must be a valid combination of VkDeviceQueueCreateFlagBits values" + } + ] + }, + "vkCreateCommandPool": { + "core": [ + { + "vuid": "VUID-vkCreateCommandPool-queueFamilyIndex-01937", + "text": " pCreateInfo->queueFamilyIndex must be the index of a queue family available in the logical device device" + }, + { + "vuid": "VUID-vkCreateCommandPool-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateCommandPool-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkCommandPoolCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateCommandPool-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateCommandPool-pCommandPool-parameter", + "text": " pCommandPool must be a valid pointer to a VkCommandPool handle" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateCommandPool-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ] + }, + "VkCommandPoolCreateInfo": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkCommandPoolCreateInfo-flags-02860", + "text": " If the protected memory feature is not enabled, the VK_COMMAND_POOL_CREATE_PROTECTED_BIT bit of flags must not be set" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkCommandPoolCreateInfo-commandPoolResetCommandBuffer-05001", + "text": " If commandPoolResetCommandBuffer is VK_FALSE, flags must not include VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT" + }, + { + "vuid": "VUID-VkCommandPoolCreateInfo-pNext-05002", + "text": " The pNext chain must include a VkCommandPoolMemoryReservationCreateInfo structure" + } + ], + "core": [ + { + "vuid": "VUID-VkCommandPoolCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO" + }, + { + "vuid": "VUID-VkCommandPoolCreateInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkCommandPoolMemoryReservationCreateInfo" + }, + { + "vuid": "VUID-VkCommandPoolCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkCommandPoolCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkCommandPoolCreateFlagBits values" + } + ] + }, + "VkCommandPoolMemoryReservationCreateInfo": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkCommandPoolMemoryReservationCreateInfo-commandPoolReservedSize-05003", + "text": " commandPoolReservedSize must be greater than 0" + }, + { + "vuid": "VUID-VkCommandPoolMemoryReservationCreateInfo-commandPoolMaxCommandBuffers-05004", + "text": " commandPoolMaxCommandBuffers must be greater than 0" + }, + { + "vuid": "VUID-VkCommandPoolMemoryReservationCreateInfo-commandPoolMaxCommandBuffers-05090", + "text": " commandPoolMaxCommandBuffers must be less than or equal to VkPhysicalDeviceVulkanSC10Properties::maxCommandPoolCommandBuffers" + }, + { + "vuid": "VUID-VkCommandPoolMemoryReservationCreateInfo-commandPoolMaxCommandBuffers-05074", + "text": " The number of command buffers reserved by all command pools plus commandPoolMaxCommandBuffers must be less than or equal to the total number of command buffers requested via VkDeviceObjectReservationCreateInfo::commandBufferRequestCount" + }, + { + "vuid": "VUID-VkCommandPoolMemoryReservationCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO" + } + ] + }, + "vkGetCommandPoolMemoryConsumption": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkGetCommandPoolMemoryConsumption-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetCommandPoolMemoryConsumption-commandPool-parameter", + "text": " commandPool must be a valid VkCommandPool handle" + }, + { + "vuid": "VUID-vkGetCommandPoolMemoryConsumption-commandBuffer-parameter", + "text": " If commandBuffer is not NULL, commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkGetCommandPoolMemoryConsumption-pConsumption-parameter", + "text": " pConsumption must be a valid pointer to a VkCommandPoolMemoryConsumption structure" + }, + { + "vuid": "VUID-vkGetCommandPoolMemoryConsumption-commandPool-parent", + "text": " commandPool must have been created, allocated, or retrieved from device" + }, + { + "vuid": "VUID-vkGetCommandPoolMemoryConsumption-commandBuffer-parent", + "text": " If commandBuffer is a valid handle, it must have been created, allocated, or retrieved from commandPool" + } + ] + }, + "VkCommandPoolMemoryConsumption": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkCommandPoolMemoryConsumption-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_CONSUMPTION" + }, + { + "vuid": "VUID-VkCommandPoolMemoryConsumption-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkResetCommandPool": { + "core": [ + { + "vuid": "VUID-vkResetCommandPool-commandPool-00040", + "text": " All VkCommandBuffer objects allocated from commandPool must not be in the pending state" + }, + { + "vuid": "VUID-vkResetCommandPool-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkResetCommandPool-commandPool-parameter", + "text": " commandPool must be a valid VkCommandPool handle" + }, + { + "vuid": "VUID-vkResetCommandPool-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-vkResetCommandPool-commandPool-parent", + "text": " commandPool must have been created, allocated, or retrieved from device" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkResetCommandPool-flags-05005", + "text": " flags must not contain VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT" + } + ] + }, + "vkDestroyCommandPool": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyCommandPool-commandPool-00041", + "text": " All VkCommandBuffer objects allocated from commandPool must not be in the pending state" + }, + { + "vuid": "VUID-vkDestroyCommandPool-commandPool-00042", + "text": " If VkAllocationCallbacks were provided when commandPool was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyCommandPool-commandPool-00043", + "text": " If no VkAllocationCallbacks were provided when commandPool was created, pAllocator must be NULL" + } + ] + }, + "vkAllocateCommandBuffers": { + "core": [ + { + "vuid": "VUID-vkAllocateCommandBuffers-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkAllocateCommandBuffers-pAllocateInfo-parameter", + "text": " pAllocateInfo must be a valid pointer to a valid VkCommandBufferAllocateInfo structure" + }, + { + "vuid": "VUID-vkAllocateCommandBuffers-pCommandBuffers-parameter", + "text": " pCommandBuffers must be a valid pointer to an array of pAllocateInfo->commandBufferCount VkCommandBuffer handles" + }, + { + "vuid": "VUID-vkAllocateCommandBuffers-pAllocateInfo::commandBufferCount-arraylength", + "text": " pAllocateInfo->commandBufferCount must be greater than 0" + } + ] + }, + "VkCommandBufferAllocateInfo": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkCommandBufferAllocateInfo-commandPool-05006", + "text": " The number of command buffers currently allocated from commandPool plus commandBufferCount must be less than or equal to the value of VkCommandPoolMemoryReservationCreateInfo::commandPoolMaxCommandBuffers specified when commandPool was created" + } + ], + "core": [ + { + "vuid": "VUID-VkCommandBufferAllocateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO" + }, + { + "vuid": "VUID-VkCommandBufferAllocateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkCommandBufferAllocateInfo-commandPool-parameter", + "text": " commandPool must be a valid VkCommandPool handle" + }, + { + "vuid": "VUID-VkCommandBufferAllocateInfo-level-parameter", + "text": " level must be a valid VkCommandBufferLevel value" + } + ] + }, + "vkResetCommandBuffer": { + "core": [ + { + "vuid": "VUID-vkResetCommandBuffer-commandBuffer-00045", + "text": " commandBuffer must not be in the pending state" + }, + { + "vuid": "VUID-vkResetCommandBuffer-commandBuffer-00046", + "text": " commandBuffer must have been allocated from a pool that was created with the VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT" + }, + { + "vuid": "VUID-vkResetCommandBuffer-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkResetCommandBuffer-flags-parameter", + "text": " flags must be a valid combination of VkCommandBufferResetFlagBits values" + } + ] + }, + "vkFreeCommandBuffers": { + "core": [ + { + "vuid": "VUID-vkFreeCommandBuffers-pCommandBuffers-00047", + "text": " All elements of pCommandBuffers must not be in the pending state" + }, + { + "vuid": "VUID-vkFreeCommandBuffers-pCommandBuffers-00048", + "text": " pCommandBuffers must be a valid pointer to an array of commandBufferCount VkCommandBuffer handles, each element of which must either be a valid handle or NULL" + }, + { + "vuid": "VUID-vkFreeCommandBuffers-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkFreeCommandBuffers-commandPool-parameter", + "text": " commandPool must be a valid VkCommandPool handle" + }, + { + "vuid": "VUID-vkFreeCommandBuffers-commandBufferCount-arraylength", + "text": " commandBufferCount must be greater than 0" + }, + { + "vuid": "VUID-vkFreeCommandBuffers-commandPool-parent", + "text": " commandPool must have been created, allocated, or retrieved from device" + }, + { + "vuid": "VUID-vkFreeCommandBuffers-pCommandBuffers-parent", + "text": " Each element of pCommandBuffers that is a valid handle must have been created, allocated, or retrieved from commandPool" + } + ] + }, + "vkBeginCommandBuffer": { + "core": [ + { + "vuid": "VUID-vkBeginCommandBuffer-commandBuffer-00049", + "text": " commandBuffer must not be in the recording or pending state" + }, + { + "vuid": "VUID-vkBeginCommandBuffer-commandBuffer-00050", + "text": " If commandBuffer was allocated from a VkCommandPool which did not have the VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT flag set, commandBuffer must be in the initial state" + }, + { + "vuid": "VUID-vkBeginCommandBuffer-commandBuffer-00051", + "text": " If commandBuffer is a secondary command buffer, the pInheritanceInfo member of pBeginInfo must be a valid VkCommandBufferInheritanceInfo structure" + }, + { + "vuid": "VUID-vkBeginCommandBuffer-commandBuffer-00052", + "text": " If commandBuffer is a secondary command buffer and either the occlusionQueryEnable member of the pInheritanceInfo member of pBeginInfo is VK_FALSE, or the precise occlusion queries feature is not enabled, then pBeginInfo->pInheritanceInfo->queryFlags must not contain VK_QUERY_CONTROL_PRECISE_BIT" + }, + { + "vuid": "VUID-vkBeginCommandBuffer-commandBuffer-02840", + "text": " If commandBuffer is a primary command buffer, then pBeginInfo->flags must not set both the VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT and the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flags" + }, + { + "vuid": "VUID-vkBeginCommandBuffer-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkBeginCommandBuffer-pBeginInfo-parameter", + "text": " pBeginInfo must be a valid pointer to a valid VkCommandBufferBeginInfo structure" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkBeginCommandBuffer-commandPoolMultipleCommandBuffersRecording-05007", + "text": " If commandPoolMultipleCommandBuffersRecording is VK_FALSE, then the command pool that commandBuffer was created from must have no other command buffers in the recording state" + }, + { + "vuid": "VUID-vkBeginCommandBuffer-commandBufferSimultaneousUse-05008", + "text": " If commandBufferSimultaneousUse is VK_FALSE, then pBeginInfo->flags must not include VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT" + } + ] + }, + "VkCommandBufferBeginInfo": { + "!(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-VkCommandBufferBeginInfo-flags-00053", + "text": " If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the renderPass member of pInheritanceInfo must be a valid VkRenderPass" + }, + { + "vuid": "VUID-VkCommandBufferBeginInfo-flags-00054", + "text": " If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the subpass member of pInheritanceInfo must be a valid subpass index within the renderPass member of pInheritanceInfo" + } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkCommandBufferBeginInfo-flags-00055", + "text": " If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the framebuffer member of pInheritanceInfo must be either VK_NULL_HANDLE, or a valid VkFramebuffer that is compatible with the renderPass member of pInheritanceInfo" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkCommandBufferBeginInfo-flags-05009", + "text": " If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT and secondaryCommandBufferNullOrImagelessFramebuffer is VK_TRUE, the framebuffer member of pInheritanceInfo must be either VK_NULL_HANDLE, or a valid VkFramebuffer that is compatible with the renderPass member of pInheritanceInfo" + }, + { + "vuid": "VUID-VkCommandBufferBeginInfo-flags-05010", + "text": " If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT and secondaryCommandBufferNullOrImagelessFramebuffer is VK_FALSE, the framebuffer member of pInheritanceInfo must be a valid VkFramebuffer that is compatible with the renderPass member of pInheritanceInfo and must not have been created with a VkFramebufferCreateInfo::flags value that includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT" + } + ], + "(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-VkCommandBufferBeginInfo-flags-06000", + "text": " If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT and the renderPass member of pInheritanceInfo is not VK_NULL_HANDLE, renderPass must be a valid VkRenderPass" + }, + { + "vuid": "VUID-VkCommandBufferBeginInfo-flags-06001", + "text": " If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT and the renderPass member of pInheritanceInfo is not VK_NULL_HANDLE, the subpass member of pInheritanceInfo must be a valid subpass index within the renderPass member of pInheritanceInfo" + }, + { + "vuid": "VUID-VkCommandBufferBeginInfo-flags-06002", + "text": " If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT and the renderPass member of pInheritanceInfo is VK_NULL_HANDLE, the pNext chain of pInheritanceInfo must include a VkCommandBufferInheritanceRenderingInfoKHR structure" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_AMD_mixed_attachment_samples,VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-VkCommandBufferBeginInfo-flags-06003", + "text": " If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the renderPass member of pInheritanceInfo is VK_NULL_HANDLE, and the pNext chain of pInheritanceInfo includes a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, the colorAttachmentCount member of that structure must be equal to the value of VkCommandBufferInheritanceRenderingInfoKHR::colorAttachmentCount" + } + ], + "core": [ + { + "vuid": "VUID-VkCommandBufferBeginInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO" + }, + { + "vuid": "VUID-VkCommandBufferBeginInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkDeviceGroupCommandBufferBeginInfo" + }, + { + "vuid": "VUID-VkCommandBufferBeginInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkCommandBufferBeginInfo-flags-parameter", + "text": " flags must be a valid combination of VkCommandBufferUsageFlagBits values" + } + ] + }, + "VkCommandBufferInheritanceInfo": { + "core": [ + { + "vuid": "VUID-VkCommandBufferInheritanceInfo-occlusionQueryEnable-00056", + "text": " If the inherited queries feature is not enabled, occlusionQueryEnable must be VK_FALSE" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceInfo-queryFlags-00057", + "text": " If the inherited queries feature is enabled, queryFlags must be a valid combination of VkQueryControlFlagBits values" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceInfo-queryFlags-02788", + "text": " If the inherited queries feature is not enabled, queryFlags must be 0" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-02789", + "text": " If the pipeline statistics queries feature is enabled, pipelineStatistics must be a valid combination of VkQueryPipelineStatisticFlagBits values" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-00058", + "text": " If the pipeline statistics queries feature is not enabled, pipelineStatistics must be 0" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceInfo-commonparent", + "text": " Both of framebuffer, and renderPass that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "VkCommandBufferInheritanceConditionalRenderingInfoEXT": { + "(VK_EXT_conditional_rendering)": [ + { + "vuid": "VUID-VkCommandBufferInheritanceConditionalRenderingInfoEXT-conditionalRenderingEnable-01977", + "text": " If the inherited conditional rendering feature is not enabled, conditionalRenderingEnable must be VK_FALSE" + } + ] + }, + "VkCommandBufferInheritanceRenderPassTransformInfoQCOM": { + "(VK_QCOM_render_pass_transform)": [ + { + "vuid": "VUID-VkCommandBufferInheritanceRenderPassTransformInfoQCOM-transform-02864", + "text": " transform must be VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR, VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR, or VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR" + } + ] + }, + "VkCommandBufferInheritanceViewportScissorInfoNV": { + "(VK_NV_inherited_viewport_scissor)": [ + { + "vuid": "VUID-VkCommandBufferInheritanceViewportScissorInfoNV-viewportScissor2D-04782", + "text": " If the inherited viewport scissor feature is not enabled, viewportScissor2D must be VK_FALSE" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceViewportScissorInfoNV-viewportScissor2D-04783", + "text": " If the multiple viewports feature is not enabled and viewportScissor2D is VK_TRUE, then viewportDepthCount must be 1" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceViewportScissorInfoNV-viewportScissor2D-04784", + "text": " If viewportScissor2D is VK_TRUE, then viewportDepthCount must be greater than 0" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceViewportScissorInfoNV-viewportScissor2D-04785", + "text": " If viewportScissor2D is VK_TRUE, then pViewportDepths must be a valid pointer to an array of viewportDepthCount valid VkViewport structures, except any requirements on x, y, width, and height do not apply" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceViewportScissorInfoNV-viewportScissor2D-04786", + "text": " If viewportScissor2D is VK_TRUE, then the command buffer must be recorded with the VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT" + } + ] + }, + "VkCommandBufferInheritanceRenderingInfoKHR": { + "(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-VkCommandBufferInheritanceRenderingInfoKHR-colorAttachmentCount-06004", + "text": " If colorAttachmentCount is not 0, rasterizationSamples must be a valid VkSampleCountFlagBits value" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceRenderingInfoKHR-variableMultisampleRate-06005", + "text": " If the variableMultisampleRate feature is not enabled, rasterizationSamples must be a valid VkSampleCountFlagBits value" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceRenderingInfoKHR-pColorAttachmentFormats-06006", + "text": " If any element of pColorAttachmentFormats is not VK_FORMAT_UNDEFINED, it must be a format with potential format features that include VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceRenderingInfoKHR-depthAttachmentFormat-06007", + "text": " If depthAttachmentFormat is not VK_FORMAT_UNDEFINED, it must be a format with potential format features that include VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceRenderingInfoKHR-stencilAttachmentFormat-06199", + "text": " If stencilAttachmentFormat is not VK_FORMAT_UNDEFINED, it must be a format with potential format features that include VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceRenderingInfoKHR-depthAttachmentFormat-06200", + "text": " If depthAttachmentFormat is not VK_FORMAT_UNDEFINED and stencilAttachmentFormat is not VK_FORMAT_UNDEFINED, depthAttachmentFormat must equal stencilAttachmentFormat" + }, + { + "vuid": "VUID-VkCommandBufferInheritanceRenderingInfoKHR-multiview-06008", + "text": " If the multiview feature is not enabled, viewMask must be 0" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkCommandBufferInheritanceRenderingInfoKHR-viewMask-06009", + "text": " The index of the most significant bit in viewMask must be less than maxMultiviewViewCount" + } + ] + }, + "vkEndCommandBuffer": { + "core": [ + { + "vuid": "VUID-vkEndCommandBuffer-commandBuffer-00059", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkEndCommandBuffer-commandBuffer-00060", + "text": " If commandBuffer is a primary command buffer, there must not be an active render pass instance" + }, + { + "vuid": "VUID-vkEndCommandBuffer-commandBuffer-00061", + "text": " All queries made active during the recording of commandBuffer must have been made inactive" + }, + { + "vuid": "VUID-vkEndCommandBuffer-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + } + ], + "(VK_EXT_conditional_rendering)": [ + { + "vuid": "VUID-vkEndCommandBuffer-None-01978", + "text": " Conditional rendering must not be active" + } + ], + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkEndCommandBuffer-commandBuffer-01815", + "text": " If commandBuffer is a secondary command buffer, there must not be an outstanding vkCmdBeginDebugUtilsLabelEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdEndDebugUtilsLabelEXT" + } + ], + "(VK_EXT_debug_marker)": [ + { + "vuid": "VUID-vkEndCommandBuffer-commandBuffer-00062", + "text": " If commandBuffer is a secondary command buffer, there must not be an outstanding vkCmdDebugMarkerBeginEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdDebugMarkerEndEXT" + } + ] + }, + "vkQueueSubmit2KHR": { + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkQueueSubmit2KHR-fence-04894", + "text": " If fence is not VK_NULL_HANDLE, fence must be unsignaled" + }, + { + "vuid": "VUID-vkQueueSubmit2KHR-fence-04895", + "text": " If fence is not VK_NULL_HANDLE, fence must not be associated with any other queue command that has not yet completed execution on that queue" + }, + { + "vuid": "VUID-vkQueueSubmit2KHR-synchronization2-03866", + "text": " The synchronization2 feature must be enabled" + }, + { + "vuid": "VUID-vkQueueSubmit2KHR-commandBuffer-03867", + "text": " If a command recorded into the commandBuffer member of any element of the pCommandBufferInfos member of any element of pSubmits referenced an VkEvent, that event must not be referenced by a command that has been submitted to another queue and is still in the pending state" + }, + { + "vuid": "VUID-vkQueueSubmit2KHR-semaphore-03868", + "text": " The semaphore member of any binary semaphore element of the pSignalSemaphoreInfos member of any element of pSubmits must be unsignaled when the semaphore signal operation it defines is executed on the device" + }, + { + "vuid": "VUID-vkQueueSubmit2KHR-stageMask-03869", + "text": " The stageMask member of any element of the pSignalSemaphoreInfos member of any element of pSubmits must only include pipeline stages that are supported by the queue family which queue belongs to" + }, + { + "vuid": "VUID-vkQueueSubmit2KHR-stageMask-03870", + "text": " The stageMask member of any element of the pWaitSemaphoreInfos member of any element of pSubmits must only include pipeline stages that are supported by the queue family which queue belongs to" + }, + { + "vuid": "VUID-vkQueueSubmit2KHR-semaphore-03871", + "text": " When a semaphore wait operation for a binary semaphore is executed, as defined by the semaphore member of any element of the pWaitSemaphoreInfos member of any element of pSubmits, there must be no other queues waiting on the same semaphore" + }, + { + "vuid": "VUID-vkQueueSubmit2KHR-semaphore-03872", + "text": " The semaphore member of any element of the pWaitSemaphoreInfos member of any element of pSubmits must be semaphores that are signaled, or have semaphore signal operations previously submitted for execution" + }, + { + "vuid": "VUID-vkQueueSubmit2KHR-commandBuffer-03874", + "text": " The commandBuffer member of any element of the pCommandBufferInfos member of any element of pSubmits must be in the pending or executable state" + }, + { + "vuid": "VUID-vkQueueSubmit2KHR-commandBuffer-03875", + "text": " If a command recorded into the commandBuffer member of any element of the pCommandBufferInfos member of any element of pSubmits was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, it must not be in the pending state" + }, + { + "vuid": "VUID-vkQueueSubmit2KHR-commandBuffer-03876", + "text": " Any secondary command buffers recorded into the commandBuffer member of any element of the pCommandBufferInfos member of any element of pSubmits must be in the pending or executable state" + }, + { + "vuid": "VUID-vkQueueSubmit2KHR-commandBuffer-03877", + "text": " If any secondary command buffers recorded into the commandBuffer member of any element of the pCommandBufferInfos member of any element of pSubmits was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, it must not be in the pending state" + }, + { + "vuid": "VUID-vkQueueSubmit2KHR-commandBuffer-03878", + "text": " The commandBuffer member of any element of the pCommandBufferInfos member of any element of pSubmits must have been allocated from a VkCommandPool that was created for the same queue family queue belongs to" + }, + { + "vuid": "VUID-vkQueueSubmit2KHR-commandBuffer-03879", + "text": " If a command recorded into the commandBuffer member of any element of the pCommandBufferInfos member of any element of pSubmits includes a Queue Family Transfer Acquire Operation, there must exist a previously submitted Queue Family Transfer Release Operation on a queue in the queue family identified by the acquire operation, with parameters matching the acquire operation as defined in the definition of such acquire operations, and which happens before the acquire operation" + }, + { + "vuid": "VUID-vkQueueSubmit2KHR-queue-parameter", + "text": " queue must be a valid VkQueue handle" + }, + { + "vuid": "VUID-vkQueueSubmit2KHR-pSubmits-parameter", + "text": " If submitCount is not 0, pSubmits must be a valid pointer to an array of submitCount valid VkSubmitInfo2KHR structures" + }, + { + "vuid": "VUID-vkQueueSubmit2KHR-fence-parameter", + "text": " If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle" + }, + { + "vuid": "VUID-vkQueueSubmit2KHR-commonparent", + "text": " Both of fence, and queue that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-vkQueueSubmit2KHR-semaphore-03873", + "text": " Any semaphore member of any element of the pWaitSemaphoreInfos member of any element of pSubmits that was created with a VkSemaphoreTypeKHR of VK_SEMAPHORE_TYPE_BINARY_KHR must reference a semaphore signal operation that has been submitted for execution and any semaphore signal operations on which it depends (if any) must have also been submitted for execution" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkQueueSubmit2KHR-commandBuffer-03880", + "text": " If a command recorded into the commandBuffer member of any element of the pCommandBufferInfos member of any element of pSubmits was a vkCmdBeginQuery whose queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, the profiling lock must have been held continuously on the VkDevice that queue was retrieved from, throughout recording of those command buffers" + } + ], + "(VK_KHR_synchronization2)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkQueueSubmit2KHR-queue-06447", + "text": " If queue was not created with VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT, the flags member of any element of pSubmits must not include VK_SUBMIT_PROTECTED_BIT_KHR" + } + ] + }, + "VkSubmitInfo2KHR": { + "(VK_KHR_synchronization2)+(VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-VkSubmitInfo2KHR-semaphore-03881", + "text": " If the same semaphore is used as the semaphore member of both an element of pSignalSemaphoreInfos and pWaitSemaphoreInfos, and that semaphore is a timeline semaphore, the value member of the pSignalSemaphoreInfos element must be greater than the value member of the pWaitSemaphoreInfos element" + }, + { + "vuid": "VUID-VkSubmitInfo2KHR-semaphore-03882", + "text": " If the semaphore member of any element of pSignalSemaphoreInfos is a timeline semaphore, the value member of that element must have a value greater than the current value of the semaphore when the semaphore signal operation is executed" + }, + { + "vuid": "VUID-VkSubmitInfo2KHR-semaphore-03883", + "text": " If the semaphore member of any element of pSignalSemaphoreInfos is a timeline semaphore, the value member of that element must have a value which does not differ from the current value of the semaphore or the value of any outstanding semaphore wait or signal operation on that semaphore by more than maxTimelineSemaphoreValueDifference" + }, + { + "vuid": "VUID-VkSubmitInfo2KHR-semaphore-03884", + "text": " If the semaphore member of any element of pWaitSemaphoreInfos is a timeline semaphore, the value member of that element must have a value which does not differ from the current value of the semaphore or the value of any outstanding semaphore wait or signal operation on that semaphore by more than maxTimelineSemaphoreValueDifference" + } + ], + "(VK_KHR_synchronization2)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkSubmitInfo2KHR-flags-03886", + "text": " If flags includes VK_SUBMIT_PROTECTED_BIT_KHR, all elements of pCommandBuffers must be protected command buffers" + }, + { + "vuid": "VUID-VkSubmitInfo2KHR-flags-03887", + "text": " If flags does not include VK_SUBMIT_PROTECTED_BIT_KHR, each element of pCommandBuffers must not be a protected command buffer" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-VkSubmitInfo2KHR-commandBuffer-06192", + "text": " If any commandBuffer member of an element of pCommandBufferInfos contains any resumed render pass instances, they must be suspended by a render pass instance earlier in submission order within pCommandBufferInfos" + }, + { + "vuid": "VUID-VkSubmitInfo2KHR-commandBuffer-06010", + "text": " If any commandBuffer member of an element of pCommandBufferInfos contains any suspended render pass instances, they must be resumed by a render pass instance later in submission order within pCommandBufferInfos" + }, + { + "vuid": "VUID-VkSubmitInfo2KHR-commandBuffer-06011", + "text": " If any commandBuffer member of an element of pCommandBufferInfos contains any suspended render pass instances, there must be no action or synchronization commands between that render pass instance and the render pass instance that resumes it" + }, + { + "vuid": "VUID-VkSubmitInfo2KHR-commandBuffer-06012", + "text": " If any commandBuffer member of an element of pCommandBufferInfos contains any suspended render pass instances, there must be no render pass instances between that render pass instance and the render pass instance that resumes it" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_dynamic_rendering)+(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-VkSubmitInfo2KHR-variableSampleLocations-06013", + "text": " If the variableSampleLocations limit is not supported, and any commandBuffer member of an element of pCommandBufferInfos contains any suspended render pass instances, where a graphics pipeline has been bound, any pipelines bound in the render pass instance that resumes it, or any subsequent render pass instances that resume from that one and so on, must use the same sample locations" + } + ], + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-VkSubmitInfo2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR" + }, + { + "vuid": "VUID-VkSubmitInfo2KHR-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkPerformanceQuerySubmitInfoKHR" + }, + { + "vuid": "VUID-VkSubmitInfo2KHR-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkSubmitInfo2KHR-flags-parameter", + "text": " flags must be a valid combination of VkSubmitFlagBitsKHR values" + }, + { + "vuid": "VUID-VkSubmitInfo2KHR-pWaitSemaphoreInfos-parameter", + "text": " If waitSemaphoreInfoCount is not 0, pWaitSemaphoreInfos must be a valid pointer to an array of waitSemaphoreInfoCount valid VkSemaphoreSubmitInfoKHR structures" + }, + { + "vuid": "VUID-VkSubmitInfo2KHR-pCommandBufferInfos-parameter", + "text": " If commandBufferInfoCount is not 0, pCommandBufferInfos must be a valid pointer to an array of commandBufferInfoCount valid VkCommandBufferSubmitInfoKHR structures" + }, + { + "vuid": "VUID-VkSubmitInfo2KHR-pSignalSemaphoreInfos-parameter", + "text": " If signalSemaphoreInfoCount is not 0, pSignalSemaphoreInfos must be a valid pointer to an array of signalSemaphoreInfoCount valid VkSemaphoreSubmitInfoKHR structures" + } + ] + }, + "VkSemaphoreSubmitInfoKHR": { + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-VkSemaphoreSubmitInfoKHR-stageMask-03929", + "text": " If the geometry shaders feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-VkSemaphoreSubmitInfoKHR-stageMask-03930", + "text": " If the tessellation shaders feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR or VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-VkSemaphoreSubmitInfoKHR-device-03888", + "text": " If the device that semaphore was created on is not a device group, deviceIndex must be 0" + }, + { + "vuid": "VUID-VkSemaphoreSubmitInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR" + }, + { + "vuid": "VUID-VkSemaphoreSubmitInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkSemaphoreSubmitInfoKHR-semaphore-parameter", + "text": " semaphore must be a valid VkSemaphore handle" + }, + { + "vuid": "VUID-VkSemaphoreSubmitInfoKHR-stageMask-parameter", + "text": " stageMask must be a valid combination of VkPipelineStageFlagBits2KHR values" + } + ], + "(VK_KHR_synchronization2)+(VK_EXT_conditional_rendering)": [ + { + "vuid": "VUID-VkSemaphoreSubmitInfoKHR-stageMask-03931", + "text": " If the conditional rendering feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT" + } + ], + "(VK_KHR_synchronization2)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkSemaphoreSubmitInfoKHR-stageMask-03932", + "text": " If the fragment density map feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + } + ], + "(VK_KHR_synchronization2)+(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-VkSemaphoreSubmitInfoKHR-stageMask-03933", + "text": " If the transform feedback feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT" + } + ], + "(VK_KHR_synchronization2)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-VkSemaphoreSubmitInfoKHR-stageMask-03934", + "text": " If the mesh shaders feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV" + }, + { + "vuid": "VUID-VkSemaphoreSubmitInfoKHR-stageMask-03935", + "text": " If the task shaders feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV" + } + ], + "(VK_KHR_synchronization2)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkSemaphoreSubmitInfoKHR-stageMask-04956", + "text": " If the shading rate image feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV" + } + ], + "(VK_KHR_synchronization2)+(VK_HUAWEI_subpass_shading)": [ + { + "vuid": "VUID-VkSemaphoreSubmitInfoKHR-stageMask-04957", + "text": " If the subpass shading feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI" + } + ], + "(VK_KHR_synchronization2)+(VK_HUAWEI_invocation_mask)": [ + { + "vuid": "VUID-VkSemaphoreSubmitInfoKHR-stageMask-04995", + "text": " If the invocation mask image feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_device_group_creation,VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkSemaphoreSubmitInfoKHR-device-03889", + "text": " If the device that semaphore was created on is a device group, deviceIndex must be a valid device index" + } + ] + }, + "VkCommandBufferSubmitInfoKHR": { + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-VkCommandBufferSubmitInfoKHR-commandBuffer-03890", + "text": " commandBuffer must not have been allocated with VK_COMMAND_BUFFER_LEVEL_SECONDARY" + }, + { + "vuid": "VUID-VkCommandBufferSubmitInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR" + }, + { + "vuid": "VUID-VkCommandBufferSubmitInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkCommandBufferSubmitInfoKHR-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_device_group_creation,VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkCommandBufferSubmitInfoKHR-deviceMask-03891", + "text": " If deviceMask is not 0, it must be a valid device mask" + } + ] + }, + "vkQueueSubmit": { + "core": [ + { + "vuid": "VUID-vkQueueSubmit-fence-00063", + "text": " If fence is not VK_NULL_HANDLE, fence must be unsignaled" + }, + { + "vuid": "VUID-vkQueueSubmit-fence-00064", + "text": " If fence is not VK_NULL_HANDLE, fence must not be associated with any other queue command that has not yet completed execution on that queue" + }, + { + "vuid": "VUID-vkQueueSubmit-pCommandBuffers-00065", + "text": " Any calls to vkCmdSetEvent, vkCmdResetEvent or vkCmdWaitEvents that have been recorded into any of the command buffer elements of the pCommandBuffers member of any element of pSubmits, must not reference any VkEvent that is referenced by any of those commands in a command buffer that has been submitted to another queue and is still in the pending state" + }, + { + "vuid": "VUID-vkQueueSubmit-pWaitDstStageMask-00066", + "text": " Any stage flag included in any element of the pWaitDstStageMask member of any element of pSubmits must be a pipeline stage supported by one of the capabilities of queue, as specified in the table of supported pipeline stages" + }, + { + "vuid": "VUID-vkQueueSubmit-pSignalSemaphores-00067", + "text": " Each binary semaphore element of the pSignalSemaphores member of any element of pSubmits must be unsignaled when the semaphore signal operation it defines is executed on the device" + }, + { + "vuid": "VUID-vkQueueSubmit-pWaitSemaphores-00068", + "text": " When a semaphore wait operation referring to a binary semaphore defined by any element of the pWaitSemaphores member of any element of pSubmits executes on queue, there must be no other queues waiting on the same semaphore" + }, + { + "vuid": "VUID-vkQueueSubmit-pCommandBuffers-00070", + "text": " Each element of the pCommandBuffers member of each element of pSubmits must be in the pending or executable state" + }, + { + "vuid": "VUID-vkQueueSubmit-pCommandBuffers-00071", + "text": " If any element of the pCommandBuffers member of any element of pSubmits was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, it must not be in the pending state" + }, + { + "vuid": "VUID-vkQueueSubmit-pCommandBuffers-00072", + "text": " Any secondary command buffers recorded into any element of the pCommandBuffers member of any element of pSubmits must be in the pending or executable state" + }, + { + "vuid": "VUID-vkQueueSubmit-pCommandBuffers-00073", + "text": " If any secondary command buffers recorded into any element of the pCommandBuffers member of any element of pSubmits was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, it must not be in the pending state" + }, + { + "vuid": "VUID-vkQueueSubmit-pCommandBuffers-00074", + "text": " Each element of the pCommandBuffers member of each element of pSubmits must have been allocated from a VkCommandPool that was created for the same queue family queue belongs to" + }, + { + "vuid": "VUID-vkQueueSubmit-pSubmits-02207", + "text": " If any element of pSubmits->pCommandBuffers includes a Queue Family Transfer Acquire Operation, there must exist a previously submitted Queue Family Transfer Release Operation on a queue in the queue family identified by the acquire operation, with parameters matching the acquire operation as defined in the definition of such acquire operations, and which happens-before the acquire operation" + }, + { + "vuid": "VUID-vkQueueSubmit-pSubmits-02808", + "text": " Any resource created with VK_SHARING_MODE_EXCLUSIVE that is read by an operation specified by pSubmits must not be owned by any queue family other than the one which queue belongs to, at the time it is executed" + }, + { + "vuid": "VUID-vkQueueSubmit-pSubmits-04626", + "text": " Any resource created with VK_SHARING_MODE_CONCURRENT that is accessed by an operation specified by pSubmits must have included the queue family of queue at resource creation time" + }, + { + "vuid": "VUID-vkQueueSubmit-queue-parameter", + "text": " queue must be a valid VkQueue handle" + }, + { + "vuid": "VUID-vkQueueSubmit-pSubmits-parameter", + "text": " If submitCount is not 0, pSubmits must be a valid pointer to an array of submitCount valid VkSubmitInfo structures" + }, + { + "vuid": "VUID-vkQueueSubmit-fence-parameter", + "text": " If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle" + }, + { + "vuid": "VUID-vkQueueSubmit-commonparent", + "text": " Both of fence, and queue that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "!(VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-vkQueueSubmit-pWaitSemaphores-00069", + "text": " All elements of the pWaitSemaphores member of all elements of pSubmits must be semaphores that are signaled, or have semaphore signal operations previously submitted for execution" + } + ], + "(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-vkQueueSubmit-pWaitSemaphores-03238", + "text": " All elements of the pWaitSemaphores member of all elements of pSubmits created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_BINARY must reference a semaphore signal operation that has been submitted for execution and any semaphore signal operations on which it depends (if any) must have also been submitted for execution" + } + ], + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkQueueSubmit-pCommandBuffers-03220", + "text": " If a command recorded into any element of pCommandBuffers was a vkCmdBeginQuery whose queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, the profiling lock must have been held continuously on the VkDevice that queue was retrieved from, throughout recording of those command buffers" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkQueueSubmit-queue-06448", + "text": " If queue was not created with VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT, there must be no element of pSubmits that includes an VkProtectedSubmitInfo structure in its pNext chain with protectedSubmit equal to VK_TRUE" + } + ] + }, + "VkSubmitInfo": { + "core": [ + { + "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-04090", + "text": " If the geometry shaders feature is not enabled, pname:pWaitDstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-04091", + "text": " If the tessellation shaders feature is not enabled, pname:pWaitDstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-VkSubmitInfo-pCommandBuffers-00075", + "text": " Each element of pCommandBuffers must not have been allocated with VK_COMMAND_BUFFER_LEVEL_SECONDARY" + }, + { + "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-00078", + "text": " Each element of pWaitDstStageMask must not include VK_PIPELINE_STAGE_HOST_BIT" + }, + { + "vuid": "VUID-VkSubmitInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SUBMIT_INFO" + }, + { + "vuid": "VUID-VkSubmitInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupSubmitInfo, VkPerformanceQuerySubmitInfoKHR, VkProtectedSubmitInfo, or VkTimelineSemaphoreSubmitInfo" + }, + { + "vuid": "VUID-VkSubmitInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkSubmitInfo-pWaitSemaphores-parameter", + "text": " If waitSemaphoreCount is not 0, pWaitSemaphores must be a valid pointer to an array of waitSemaphoreCount valid VkSemaphore handles" + }, + { + "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-parameter", + "text": " If waitSemaphoreCount is not 0, pWaitDstStageMask must be a valid pointer to an array of waitSemaphoreCount valid combinations of VkPipelineStageFlagBits values" + }, + { + "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-requiredbitmask", + "text": " Each element of pWaitDstStageMask must not be 0" + }, + { + "vuid": "VUID-VkSubmitInfo-pCommandBuffers-parameter", + "text": " If commandBufferCount is not 0, pCommandBuffers must be a valid pointer to an array of commandBufferCount valid VkCommandBuffer handles" + }, + { + "vuid": "VUID-VkSubmitInfo-pSignalSemaphores-parameter", + "text": " If signalSemaphoreCount is not 0, pSignalSemaphores must be a valid pointer to an array of signalSemaphoreCount valid VkSemaphore handles" + }, + { + "vuid": "VUID-VkSubmitInfo-commonparent", + "text": " Each of the elements of pCommandBuffers, the elements of pSignalSemaphores, and the elements of pWaitSemaphores that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_EXT_conditional_rendering)": [ + { + "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-04092", + "text": " If the conditional rendering feature is not enabled, pname:pWaitDstStageMask must not contain VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT" + } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-04093", + "text": " If the fragment density map feature is not enabled, pname:pWaitDstStageMask must not contain VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + } + ], + "(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-04094", + "text": " If the transform feedback feature is not enabled, pname:pWaitDstStageMask must not contain VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT" + } + ], + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-04095", + "text": " If the mesh shaders feature is not enabled, pname:pWaitDstStageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV" + }, + { + "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-04096", + "text": " If the task shaders feature is not enabled, pname:pWaitDstStageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV" + } + ], + "(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-04097", + "text": " If the shading rate image feature is not enabled, pname:pWaitDstStageMask must not contain VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV" + } + ], + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-03937", + "text": " If the synchronization2 feature is not enabled, pname:pWaitDstStageMask must not be 0" + } + ], + "!(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-VkSubmitInfo-pWaitDstStageMask-04996", + "text": " pname:pWaitDstStageMask must not be 0" + } + ], + "(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-VkSubmitInfo-pWaitSemaphores-03239", + "text": " If any element of pWaitSemaphores or pSignalSemaphores was created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE, then the pNext chain must include a VkTimelineSemaphoreSubmitInfo structure" + }, + { + "vuid": "VUID-VkSubmitInfo-pNext-03240", + "text": " If the pNext chain of this structure includes a VkTimelineSemaphoreSubmitInfo structure and any element of pWaitSemaphores was created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE, then its waitSemaphoreValueCount member must equal waitSemaphoreCount" + }, + { + "vuid": "VUID-VkSubmitInfo-pNext-03241", + "text": " If the pNext chain of this structure includes a VkTimelineSemaphoreSubmitInfo structure and any element of pSignalSemaphores was created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE, then its signalSemaphoreValueCount member must equal signalSemaphoreCount" + }, + { + "vuid": "VUID-VkSubmitInfo-pSignalSemaphores-03242", + "text": " For each element of pSignalSemaphores created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE the corresponding element of VkTimelineSemaphoreSubmitInfo::pSignalSemaphoreValues must have a value greater than the current value of the semaphore when the semaphore signal operation is executed" + }, + { + "vuid": "VUID-VkSubmitInfo-pWaitSemaphores-03243", + "text": " For each element of pWaitSemaphores created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE the corresponding element of VkTimelineSemaphoreSubmitInfo::pWaitSemaphoreValues must have a value which does not differ from the current value of the semaphore or the value of any outstanding semaphore wait or signal operation on that semaphore by more than maxTimelineSemaphoreValueDifference" + }, + { + "vuid": "VUID-VkSubmitInfo-pSignalSemaphores-03244", + "text": " For each element of pSignalSemaphores created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE the corresponding element of VkTimelineSemaphoreSubmitInfo::pSignalSemaphoreValues must have a value which does not differ from the current value of the semaphore or the value of any outstanding semaphore wait or signal operation on that semaphore by more than maxTimelineSemaphoreValueDifference" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkSubmitInfo-pNext-04120", + "text": " If the pNext chain of this structure does not include a VkProtectedSubmitInfo structure with protectedSubmit set to VK_TRUE, then each element of the pCommandBuffers array must be an unprotected command buffer" + }, + { + "vuid": "VUID-VkSubmitInfo-pNext-04148", + "text": " If the pNext chain of this structure includes a VkProtectedSubmitInfo structure with protectedSubmit set to VK_TRUE, then each element of the pCommandBuffers array must be a protected command buffer" + } + ], + "(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-VkSubmitInfo-pCommandBuffers-06193", + "text": " If pCommandBuffers contains any resumed render pass instances, they must be suspended by a render pass instance earlier in submission order within pCommandBuffers" + }, + { + "vuid": "VUID-VkSubmitInfo-pCommandBuffers-06014", + "text": " If pCommandBuffers contains any suspended render pass instances, they must be resumed by a render pass instance later in submission order within pCommandBuffers" + }, + { + "vuid": "VUID-VkSubmitInfo-pCommandBuffers-06015", + "text": " If pCommandBuffers contains any suspended render pass instances, there must be no action or synchronization commands between that render pass instance and the render pass instance that resumes it" + }, + { + "vuid": "VUID-VkSubmitInfo-pCommandBuffers-06016", + "text": " If pCommandBuffers contains any suspended render pass instances, there must be no render pass instances between that render pass instance and the render pass instance that resumes it" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-VkSubmitInfo-variableSampleLocations-06017", + "text": " If the variableSampleLocations limit is not supported, and any element of pCommandBuffers contains any suspended render pass instances, where a graphics pipeline has been bound, any pipelines bound in the render pass instance that resumes it, or any subsequent render pass instances that resume from that one and so on, must use the same sample locations" + } + ] + }, + "VkTimelineSemaphoreSubmitInfo": { + "(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-VkTimelineSemaphoreSubmitInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO" + }, + { + "vuid": "VUID-VkTimelineSemaphoreSubmitInfo-pWaitSemaphoreValues-parameter", + "text": " If waitSemaphoreValueCount is not 0, and pWaitSemaphoreValues is not NULL, pWaitSemaphoreValues must be a valid pointer to an array of waitSemaphoreValueCount uint64_t values" + }, + { + "vuid": "VUID-VkTimelineSemaphoreSubmitInfo-pSignalSemaphoreValues-parameter", + "text": " If signalSemaphoreValueCount is not 0, and pSignalSemaphoreValues is not NULL, pSignalSemaphoreValues must be a valid pointer to an array of signalSemaphoreValueCount uint64_t values" + } + ] + }, + "VkD3D12FenceSubmitInfoKHR": { + "(VK_KHR_external_semaphore_win32)": [ + { + "vuid": "VUID-VkD3D12FenceSubmitInfoKHR-waitSemaphoreValuesCount-00079", + "text": " waitSemaphoreValuesCount must be the same value as VkSubmitInfo::waitSemaphoreCount, where VkSubmitInfo is in the pNext chain of this VkD3D12FenceSubmitInfoKHR structure" + }, + { + "vuid": "VUID-VkD3D12FenceSubmitInfoKHR-signalSemaphoreValuesCount-00080", + "text": " signalSemaphoreValuesCount must be the same value as VkSubmitInfo::signalSemaphoreCount, where VkSubmitInfo is in the pNext chain of this VkD3D12FenceSubmitInfoKHR structure" + } + ] + }, + "VkWin32KeyedMutexAcquireReleaseInfoKHR": { + "(VK_KHR_win32_keyed_mutex)": [ + { + "vuid": "VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireSyncs-00081", + "text": " Each member of pAcquireSyncs and pReleaseSyncs must be a device memory object imported by setting VkImportMemoryWin32HandleInfoKHR::handleType to VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT" + } + ] + }, + "VkProtectedSubmitInfo": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkProtectedSubmitInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO" + } + ] + }, + "VkDeviceGroupSubmitInfo": { + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkDeviceGroupSubmitInfo-waitSemaphoreCount-00082", + "text": " waitSemaphoreCount must equal VkSubmitInfo::waitSemaphoreCount" + }, + { + "vuid": "VUID-VkDeviceGroupSubmitInfo-commandBufferCount-00083", + "text": " commandBufferCount must equal VkSubmitInfo::commandBufferCount" + }, + { + "vuid": "VUID-VkDeviceGroupSubmitInfo-signalSemaphoreCount-00084", + "text": " signalSemaphoreCount must equal VkSubmitInfo::signalSemaphoreCount" + }, + { + "vuid": "VUID-VkDeviceGroupSubmitInfo-pWaitSemaphoreDeviceIndices-00085", + "text": " All elements of pWaitSemaphoreDeviceIndices and pSignalSemaphoreDeviceIndices must be valid device indices" + }, + { + "vuid": "VUID-VkDeviceGroupSubmitInfo-pCommandBufferDeviceMasks-00086", + "text": " All elements of pCommandBufferDeviceMasks must be valid device masks" + }, + { + "vuid": "VUID-VkDeviceGroupSubmitInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO" + }, + { + "vuid": "VUID-VkDeviceGroupSubmitInfo-pWaitSemaphoreDeviceIndices-parameter", + "text": " If waitSemaphoreCount is not 0, pWaitSemaphoreDeviceIndices must be a valid pointer to an array of waitSemaphoreCount uint32_t values" + }, + { + "vuid": "VUID-VkDeviceGroupSubmitInfo-pCommandBufferDeviceMasks-parameter", + "text": " If commandBufferCount is not 0, pCommandBufferDeviceMasks must be a valid pointer to an array of commandBufferCount uint32_t values" + }, + { + "vuid": "VUID-VkDeviceGroupSubmitInfo-pSignalSemaphoreDeviceIndices-parameter", + "text": " If signalSemaphoreCount is not 0, pSignalSemaphoreDeviceIndices must be a valid pointer to an array of signalSemaphoreCount uint32_t values" + } + ] + }, + "VkPerformanceQuerySubmitInfoKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-VkPerformanceQuerySubmitInfoKHR-counterPassIndex-03221", + "text": " counterPassIndex must be less than the number of counter passes required by any queries within the batch. The required number of counter passes for a performance query is obtained by calling vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR" + }, + { + "vuid": "VUID-VkPerformanceQuerySubmitInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR" + } + ] + }, + "vkCmdExecuteCommands": { + "core": [ + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00088", + "text": " Each element of pCommandBuffers must have been allocated with a level of VK_COMMAND_BUFFER_LEVEL_SECONDARY" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00089", + "text": " Each element of pCommandBuffers must be in the pending or executable state" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00091", + "text": " If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, it must not be in the pending state" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00092", + "text": " If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, it must not have already been recorded to commandBuffer" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00093", + "text": " If any element of pCommandBuffers was not recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag, it must not appear more than once in pCommandBuffers" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00094", + "text": " Each element of pCommandBuffers must have been allocated from a VkCommandPool that was created for the same queue family as the VkCommandPool from which commandBuffer was allocated" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00096", + "text": " If vkCmdExecuteCommands is being called within a render pass instance, each element of pCommandBuffers must have been recorded with the VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00099", + "text": " If vkCmdExecuteCommands is being called within a render pass instance, and any element of pCommandBuffers was recorded with VkCommandBufferInheritanceInfo::framebuffer not equal to VK_NULL_HANDLE, that VkFramebuffer must match the VkFramebuffer used in the current render pass instance" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-contents-06018", + "text": " If vkCmdExecuteCommands is being called within a render pass instance begun with vkCmdBeginRenderPass, its contents parameter must have been set to VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-06019", + "text": " If vkCmdExecuteCommands is being called within a render pass instance begun with vkCmdBeginRenderPass, each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::subpass set to the index of the subpass which the given command buffer will be executed in" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pBeginInfo-06020", + "text": " If vkCmdExecuteCommands is being called within a render pass instance begun with vkCmdBeginRenderPass, the render passes specified in the pBeginInfo->pInheritanceInfo->renderPass members of the vkBeginCommandBuffer commands used to begin recording each element of pCommandBuffers must be compatible with the current render pass" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00100", + "text": " If vkCmdExecuteCommands is not being called within a render pass instance, each element of pCommandBuffers must not have been recorded with the VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-00101", + "text": " If the inherited queries feature is not enabled, commandBuffer must not have any queries active" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-00102", + "text": " If commandBuffer has a VK_QUERY_TYPE_OCCLUSION query active, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::occlusionQueryEnable set to VK_TRUE" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-00103", + "text": " If commandBuffer has a VK_QUERY_TYPE_OCCLUSION query active, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::queryFlags having all bits set that are set for the query" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-00104", + "text": " If commandBuffer has a VK_QUERY_TYPE_PIPELINE_STATISTICS query active, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::pipelineStatistics having all bits set that are set in the VkQueryPool the query uses" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00105", + "text": " Each element of pCommandBuffers must not begin any query types that are active in commandBuffer" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-parameter", + "text": " pCommandBuffers must be a valid pointer to an array of commandBufferCount valid VkCommandBuffer handles" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-bufferlevel", + "text": " commandBuffer must be a primary VkCommandBuffer" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-commandBufferCount-arraylength", + "text": " commandBufferCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-commonparent", + "text": " Both of commandBuffer, and the elements of pCommandBuffers must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "!(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdExecuteCommands-contents-00095", + "text": " If vkCmdExecuteCommands is being called within a render pass instance, that render pass instance must have been begun with the contents parameter of vkCmdBeginRenderPass set to VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00097", + "text": " If vkCmdExecuteCommands is being called within a render pass instance, each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::subpass set to the index of the subpass which the given command buffer will be executed in" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pInheritanceInfo-00098", + "text": " If vkCmdExecuteCommands is being called within a render pass instance, the render passes specified in the pBeginInfo->pInheritanceInfo->renderPass members of the vkBeginCommandBuffer commands used to begin recording each element of pCommandBuffers must be compatible with the current render pass" + } + ], + "(VK_QCOM_render_pass_transform)": [ + { + "vuid": "VUID-vkCmdExecuteCommands-pNext-02865", + "text": " If vkCmdExecuteCommands is being called within a render pass instance that included VkRenderPassTransformBeginInfoQCOM in the pNext chain of VkRenderPassBeginInfo, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceRenderPassTransformInfoQCOM in the pNext chain of VkCommandBufferBeginInfo" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pNext-02866", + "text": " If vkCmdExecuteCommands is being called within a render pass instance that included VkRenderPassTransformBeginInfoQCOM in the pNext chain of VkRenderPassBeginInfo, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceRenderPassTransformInfoQCOM::transform identical to VkRenderPassTransformBeginInfoQCOM::transform" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pNext-02867", + "text": " If vkCmdExecuteCommands is being called within a render pass instance that included VkRenderPassTransformBeginInfoQCOM in the pNext chain of VkRenderPassBeginInfo, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceRenderPassTransformInfoQCOM::renderArea identical to VkRenderPassBeginInfo::renderArea" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-01820", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, each element of pCommandBuffers must be a protected command buffer" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-01821", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, each element of pCommandBuffers must be an unprotected command buffer" + } + ], + "(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdExecuteCommands-None-02286", + "text": " This command must not be recorded when transform feedback is active" + } + ], + "(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-06021", + "text": " If pCommandBuffers contains any suspended render pass instances, there must be no action or synchronization commands between that render pass instance and any render pass instance that resumes it" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-06022", + "text": " If pCommandBuffers contains any suspended render pass instances, there must be no render pass instances between that render pass instance and any render pass instance that resumes it" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-flags-06024", + "text": " If vkCmdExecuteCommands is being called within a render pass instance begun with vkCmdBeginRenderingKHR, its VkRenderingInfoKHR::flags parameter must have included VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pBeginInfo-06025", + "text": " If vkCmdExecuteCommands is being called within a render pass instance begun with vkCmdBeginRenderingKHR, the render passes specified in the pBeginInfo->pInheritanceInfo->renderPass members of the vkBeginCommandBuffer commands used to begin recording each element of pCommandBuffers must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-flags-06026", + "text": " If vkCmdExecuteCommands is being called within a render pass instance begun with vkCmdBeginRenderingKHR, the flags member of the VkCommandBufferInheritanceRenderingInfoKHR structure included in the pNext chain of VkCommandBufferBeginInfo::pInheritanceInfo used to begin recording each element of pCommandBuffers must be equal to the VkRenderingInfoKHR::flags parameter to vkCmdBeginRenderingKHR, excluding VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-colorAttachmentCount-06027", + "text": " If vkCmdExecuteCommands is being called within a render pass instance begun with vkCmdBeginRenderingKHR, the colorAttachmentCount member of the VkCommandBufferInheritanceRenderingInfoKHR structure included in the pNext chain of VkCommandBufferBeginInfo::pInheritanceInfo used to begin recording each element of pCommandBuffers must be equal to the VkRenderingInfoKHR::colorAttachmentCount parameter to vkCmdBeginRenderingKHR" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-imageView-06028", + "text": " If vkCmdExecuteCommands is being called within a render pass instance begun with vkCmdBeginRenderingKHR, if the imageView member of an element of the VkRenderingInfoKHR::pColorAttachments parameter to vkCmdBeginRenderingKHR is not VK_NULL_HANDLE, the corresponding element of the pColorAttachmentFormats member of the VkCommandBufferInheritanceRenderingInfoKHR structure included in the pNext chain of VkCommandBufferBeginInfo::pInheritanceInfo used to begin recording each element of pCommandBuffers must be equal to the format used to create that image view" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pDepthAttachment-06029", + "text": " If vkCmdExecuteCommands is being called within a render pass instance begun with vkCmdBeginRenderingKHR, if the VkRenderingInfoKHR::pDepthAttachment->imageView parameter to vkCmdBeginRenderingKHR is not VK_NULL_HANDLE, the value of the depthAttachmentFormat member of the VkCommandBufferInheritanceRenderingInfoKHR structure included in the pNext chain of VkCommandBufferBeginInfo::pInheritanceInfo used to begin recording each element of pCommandBuffers must be equal to the format used to create that image view" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pStencilAttachment-06030", + "text": " If vkCmdExecuteCommands is being called within a render pass instance begun with vkCmdBeginRenderingKHR, if the VkRenderingInfoKHR::pStencilAttachment->imageView parameter to vkCmdBeginRenderingKHR is not VK_NULL_HANDLE, the value of the stencilAttachmentFormat member of the VkCommandBufferInheritanceRenderingInfoKHR structure included in the pNext chain of VkCommandBufferBeginInfo::pInheritanceInfo used to begin recording each element of pCommandBuffers must be equal to the format used to create that image view" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdExecuteCommands-variableSampleLocations-06023", + "text": " If the variableSampleLocations limit is not supported, and any element of pCommandBuffers contains any suspended render pass instances, where a graphics pipeline has been bound, any pipelines bound in the render pass instance that resumes it, or any subsequent render pass instances that resume from that one and so on, must use the same sample locations" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_KHR_multiview,VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdExecuteCommands-viewMask-06031", + "text": " If vkCmdExecuteCommands is being called within a render pass instance begun with vkCmdBeginRenderingKHR, the viewMask member of the VkCommandBufferInheritanceRenderingInfoKHR structure included in the pNext chain of VkCommandBufferBeginInfo::pInheritanceInfo used to begin recording each element of pCommandBuffers must be equal to the VkRenderingInfoKHR::viewMask parameter to vkCmdBeginRenderingKHR" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_AMD_mixed_attachment_samples,VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-vkCmdExecuteCommands-pNext-06032", + "text": " If vkCmdExecuteCommands is being called within a render pass instance begun with vkCmdBeginRenderingKHR and the pNext chain of VkCommandBufferInheritanceInfo includes a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, if the imageView member of an element of the VkRenderingInfoKHR::pColorAttachments parameter to vkCmdBeginRenderingKHR is not VK_NULL_HANDLE, the corresponding element of the pColorAttachmentSamples member of the VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure included in the pNext chain of VkCommandBufferBeginInfo::pInheritanceInfo used to begin recording each element of pCommandBuffers must be equal to the sample count used to create that image view" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pNext-06033", + "text": " If vkCmdExecuteCommands is being called within a render pass instance begun with vkCmdBeginRenderingKHR and the pNext chain of VkCommandBufferInheritanceInfo includes a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, if the VkRenderingInfoKHR::pDepthAttachment->imageView parameter to vkCmdBeginRenderingKHR is not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of the VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure included in the pNext chain of VkCommandBufferBeginInfo::pInheritanceInfo used to begin recording each element of pCommandBuffers must be equal to the sample count used to create that image view" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pNext-06034", + "text": " If vkCmdExecuteCommands is being called within a render pass instance begun with vkCmdBeginRenderingKHR and the pNext chain of VkCommandBufferInheritanceInfo includes a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, if the VkRenderingInfoKHR::pStencilAttachment->imageView parameter to vkCmdBeginRenderingKHR is not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of the VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure included in the pNext chain of VkCommandBufferBeginInfo::pInheritanceInfo used to begin recording each element of pCommandBuffers must be equal to the sample count used to create that image view" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pNext-06035", + "text": " If vkCmdExecuteCommands is being called within a render pass instance begun with vkCmdBeginRenderingKHR and the pNext chain of VkCommandBufferInheritanceInfo does not include a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, if the imageView member of an element of the VkRenderingInfoKHR::pColorAttachments parameter to vkCmdBeginRenderingKHR is not VK_NULL_HANDLE, the value of VkCommandBufferInheritanceRenderingInfoKHR::rasterizationSamples must be equal to the sample count used to create that image view" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pNext-06036", + "text": " If vkCmdExecuteCommands is being called within a render pass instance begun with vkCmdBeginRenderingKHR and the pNext chain of VkCommandBufferInheritanceInfo does not include a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, if the VkRenderingInfoKHR::pDepthAttachment->imageView parameter to vkCmdBeginRenderingKHR is not VK_NULL_HANDLE, the value of VkCommandBufferInheritanceRenderingInfoKHR::rasterizationSamples must be equal to the sample count used to create that image view" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pNext-06037", + "text": " If vkCmdExecuteCommands is being called within a render pass instance begun with vkCmdBeginRenderingKHR and the pNext chain of VkCommandBufferInheritanceInfo does not include a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, if the VkRenderingInfoKHR::pStencilAttachment->imageView parameter to vkCmdBeginRenderingKHR is not VK_NULL_HANDLE, the value of VkCommandBufferInheritanceRenderingInfoKHR::rasterizationSamples must be equal to the sample count used to create that image view" + } + ] + }, + "VkDeviceGroupCommandBufferBeginInfo": { + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkDeviceGroupCommandBufferBeginInfo-deviceMask-00106", + "text": " deviceMask must be a valid device mask value" + }, + { + "vuid": "VUID-VkDeviceGroupCommandBufferBeginInfo-deviceMask-00107", + "text": " deviceMask must not be zero" + }, + { + "vuid": "VUID-VkDeviceGroupCommandBufferBeginInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO" + } + ] + }, + "vkCmdSetDeviceMask": { + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkCmdSetDeviceMask-deviceMask-00108", + "text": " deviceMask must be a valid device mask value" + }, + { + "vuid": "VUID-vkCmdSetDeviceMask-deviceMask-00109", + "text": " deviceMask must not be zero" + }, + { + "vuid": "VUID-vkCmdSetDeviceMask-deviceMask-00110", + "text": " deviceMask must not include any set bits that were not in the VkDeviceGroupCommandBufferBeginInfo::deviceMask value when the command buffer began recording" + }, + { + "vuid": "VUID-vkCmdSetDeviceMask-deviceMask-00111", + "text": " If vkCmdSetDeviceMask is called inside a render pass instance, deviceMask must not include any set bits that were not in the VkDeviceGroupRenderPassBeginInfo::deviceMask value when the render pass instance began recording" + }, + { + "vuid": "VUID-vkCmdSetDeviceMask-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetDeviceMask-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetDeviceMask-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, compute, or transfer operations" + } + ] + }, + "vkCreateFence": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateFence-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "core": [ + { + "vuid": "VUID-vkCreateFence-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateFence-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkFenceCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateFence-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateFence-pFence-parameter", + "text": " pFence must be a valid pointer to a VkFence handle" + } + ] + }, + "VkFenceCreateInfo": { + "core": [ + { + "vuid": "VUID-VkFenceCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO" + }, + { + "vuid": "VUID-VkFenceCreateInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkExportFenceCreateInfo" + }, + { + "vuid": "VUID-VkFenceCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkFenceCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkFenceCreateFlagBits values" + } + ] + }, + "VkExportFenceCreateInfo": { + "(VK_VERSION_1_1,VK_KHR_external_fence)": [ + { + "vuid": "VUID-VkExportFenceCreateInfo-handleTypes-01446", + "text": " The bits in handleTypes must be supported and compatible, as reported by VkExternalFenceProperties" + }, + { + "vuid": "VUID-VkExportFenceCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO" + }, + { + "vuid": "VUID-VkExportFenceCreateInfo-handleTypes-parameter", + "text": " handleTypes must be a valid combination of VkExternalFenceHandleTypeFlagBits values" + } + ] + }, + "VkExportFenceWin32HandleInfoKHR": { + "(VK_KHR_external_fence_win32)": [ + { + "vuid": "VUID-VkExportFenceWin32HandleInfoKHR-handleTypes-01447", + "text": " If VkExportFenceCreateInfo::handleTypes does not include VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, a VkExportFenceWin32HandleInfoKHR structure must not be included in the pNext chain of VkFenceCreateInfo" + } + ] + }, + "VkFenceGetWin32HandleInfoKHR": { + "(VK_KHR_external_fence_win32)": [ + { + "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-handleType-01448", + "text": " handleType must have been included in VkExportFenceCreateInfo::handleTypes when the fence’s current payload was created" + }, + { + "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-handleType-01449", + "text": " If handleType is defined as an NT handle, vkGetFenceWin32HandleKHR must be called no more than once for each valid unique combination of fence and handleType" + }, + { + "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-fence-01450", + "text": " fence must not currently have its payload replaced by an imported payload as described below in Importing Fence Payloads unless that imported payload’s handle type was included in VkExternalFenceProperties::exportFromImportedHandleTypes for handleType" + }, + { + "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-handleType-01451", + "text": " If handleType refers to a handle type with copy payload transference semantics, fence must be signaled, or have an associated fence signal operation pending execution" + }, + { + "vuid": "VUID-VkFenceGetWin32HandleInfoKHR-handleType-01452", + "text": " handleType must be defined as an NT handle or a global share handle" + } + ] + }, + "vkGetFenceFdKHR": { + "(VK_KHR_external_fence_fd)": [ + { + "vuid": "VUID-vkGetFenceFdKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetFenceFdKHR-pGetFdInfo-parameter", + "text": " pGetFdInfo must be a valid pointer to a valid VkFenceGetFdInfoKHR structure" + }, + { + "vuid": "VUID-vkGetFenceFdKHR-pFd-parameter", + "text": " pFd must be a valid pointer to an int value" + } + ] + }, + "VkFenceGetFdInfoKHR": { + "(VK_KHR_external_fence_fd)": [ + { + "vuid": "VUID-VkFenceGetFdInfoKHR-handleType-01453", + "text": " handleType must have been included in VkExportFenceCreateInfo::handleTypes when fence’s current payload was created" + }, + { + "vuid": "VUID-VkFenceGetFdInfoKHR-handleType-01454", + "text": " If handleType refers to a handle type with copy payload transference semantics, fence must be signaled, or have an associated fence signal operation pending execution" + }, + { + "vuid": "VUID-VkFenceGetFdInfoKHR-fence-01455", + "text": " fence must not currently have its payload replaced by an imported payload as described below in Importing Fence Payloads unless that imported payload’s handle type was included in VkExternalFenceProperties::exportFromImportedHandleTypes for handleType" + }, + { + "vuid": "VUID-VkFenceGetFdInfoKHR-handleType-01456", + "text": " handleType must be defined as a POSIX file descriptor handle" + }, + { + "vuid": "VUID-VkFenceGetFdInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR" + }, + { + "vuid": "VUID-VkFenceGetFdInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkFenceGetFdInfoKHR-fence-parameter", + "text": " fence must be a valid VkFence handle" + }, + { + "vuid": "VUID-VkFenceGetFdInfoKHR-handleType-parameter", + "text": " handleType must be a valid VkExternalFenceHandleTypeFlagBits value" + } + ] + }, + "vkDestroyFence": { + "core": [ + { + "vuid": "VUID-vkDestroyFence-fence-01120", + "text": " All queue submission commands that refer to fence must have completed execution" + }, + { + "vuid": "VUID-vkDestroyFence-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyFence-fence-parameter", + "text": " If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle" + }, + { + "vuid": "VUID-vkDestroyFence-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyFence-fence-parent", + "text": " If fence is a valid handle, it must have been created, allocated, or retrieved from device" + } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyFence-fence-01121", + "text": " If VkAllocationCallbacks were provided when fence was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyFence-fence-01122", + "text": " If no VkAllocationCallbacks were provided when fence was created, pAllocator must be NULL" + } + ] + }, + "vkGetFenceStatus": { + "core": [ + { + "vuid": "VUID-vkGetFenceStatus-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetFenceStatus-fence-parameter", + "text": " fence must be a valid VkFence handle" + }, + { + "vuid": "VUID-vkGetFenceStatus-fence-parent", + "text": " fence must have been created, allocated, or retrieved from device" + } + ] + }, + "vkResetFences": { + "core": [ + { + "vuid": "VUID-vkResetFences-pFences-01123", + "text": " Each element of pFences must not be currently associated with any queue command that has not yet completed execution on that queue" + }, + { + "vuid": "VUID-vkResetFences-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkResetFences-pFences-parameter", + "text": " pFences must be a valid pointer to an array of fenceCount valid VkFence handles" + }, + { + "vuid": "VUID-vkResetFences-fenceCount-arraylength", + "text": " fenceCount must be greater than 0" + }, + { + "vuid": "VUID-vkResetFences-pFences-parent", + "text": " Each element of pFences must have been created, allocated, or retrieved from device" + } + ] + }, + "vkWaitForFences": { + "core": [ + { + "vuid": "VUID-vkWaitForFences-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkWaitForFences-pFences-parameter", + "text": " pFences must be a valid pointer to an array of fenceCount valid VkFence handles" + }, + { + "vuid": "VUID-vkWaitForFences-fenceCount-arraylength", + "text": " fenceCount must be greater than 0" + }, + { + "vuid": "VUID-vkWaitForFences-pFences-parent", + "text": " Each element of pFences must have been created, allocated, or retrieved from device" + } + ] + }, + "vkRegisterDeviceEventEXT": { + "(VK_EXT_display_control)": [ + { + "vuid": "VUID-vkRegisterDeviceEventEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkRegisterDeviceEventEXT-pDeviceEventInfo-parameter", + "text": " pDeviceEventInfo must be a valid pointer to a valid VkDeviceEventInfoEXT structure" + }, + { + "vuid": "VUID-vkRegisterDeviceEventEXT-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkRegisterDeviceEventEXT-pFence-parameter", + "text": " pFence must be a valid pointer to a VkFence handle" + } + ] + }, + "VkDeviceEventInfoEXT": { + "(VK_EXT_display_control)": [ + { + "vuid": "VUID-VkDeviceEventInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT" + }, + { + "vuid": "VUID-VkDeviceEventInfoEXT-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDeviceEventInfoEXT-deviceEvent-parameter", + "text": " deviceEvent must be a valid VkDeviceEventTypeEXT value" + } + ] + }, + "vkRegisterDisplayEventEXT": { + "(VK_EXT_display_control)": [ + { + "vuid": "VUID-vkRegisterDisplayEventEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkRegisterDisplayEventEXT-display-parameter", + "text": " display must be a valid VkDisplayKHR handle" + }, + { + "vuid": "VUID-vkRegisterDisplayEventEXT-pDisplayEventInfo-parameter", + "text": " pDisplayEventInfo must be a valid pointer to a valid VkDisplayEventInfoEXT structure" + }, + { + "vuid": "VUID-vkRegisterDisplayEventEXT-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkRegisterDisplayEventEXT-pFence-parameter", + "text": " pFence must be a valid pointer to a VkFence handle" + }, + { + "vuid": "VUID-vkRegisterDisplayEventEXT-commonparent", + "text": " Both of device, and display must have been created, allocated, or retrieved from the same VkPhysicalDevice" + } + ] + }, + "VkDisplayEventInfoEXT": { + "(VK_EXT_display_control)": [ + { + "vuid": "VUID-VkDisplayEventInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT" + }, + { + "vuid": "VUID-VkDisplayEventInfoEXT-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDisplayEventInfoEXT-displayEvent-parameter", + "text": " displayEvent must be a valid VkDisplayEventTypeEXT value" + } + ] + }, + "vkImportFenceWin32HandleKHR": { + "(VK_KHR_external_fence_win32)": [ + { + "vuid": "VUID-vkImportFenceWin32HandleKHR-fence-04448", + "text": " fence must not be associated with any queue command that has not yet completed execution on that queue" + } + ] + }, + "VkImportFenceWin32HandleInfoKHR": { + "(VK_KHR_external_fence_win32)": [ + { + "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handleType-01457", + "text": " handleType must be a value included in the Handle Types Supported by VkImportFenceWin32HandleInfoKHR table" + }, + { + "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handleType-01459", + "text": " If handleType is not VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, name must be NULL" + }, + { + "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handleType-01460", + "text": " If handle is NULL, name must name a valid synchronization primitive of the type specified by handleType" + }, + { + "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handleType-01461", + "text": " If name is NULL, handle must be a valid handle of the type specified by handleType" + }, + { + "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handle-01462", + "text": " If handle is not NULL, name must be NULL" + }, + { + "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-handle-01539", + "text": " If handle is not NULL, it must obey any requirements listed for handleType in external fence handle types compatibility" + }, + { + "vuid": "VUID-VkImportFenceWin32HandleInfoKHR-name-01540", + "text": " If name is not NULL, it must obey any requirements listed for handleType in external fence handle types compatibility" + } + ] + }, + "vkImportFenceFdKHR": { + "(VK_KHR_external_fence_fd)": [ + { + "vuid": "VUID-vkImportFenceFdKHR-fence-01463", + "text": " fence must not be associated with any queue command that has not yet completed execution on that queue" + }, + { + "vuid": "VUID-vkImportFenceFdKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkImportFenceFdKHR-pImportFenceFdInfo-parameter", + "text": " pImportFenceFdInfo must be a valid pointer to a valid VkImportFenceFdInfoKHR structure" + } + ] + }, + "VkImportFenceFdInfoKHR": { + "(VK_KHR_external_fence_fd)": [ + { + "vuid": "VUID-VkImportFenceFdInfoKHR-handleType-01464", + "text": " handleType must be a value included in the Handle Types Supported by VkImportFenceFdInfoKHR table" + }, + { + "vuid": "VUID-VkImportFenceFdInfoKHR-fd-01541", + "text": " fd must obey any requirements listed for handleType in external fence handle types compatibility" + }, + { + "vuid": "VUID-VkImportFenceFdInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR" + }, + { + "vuid": "VUID-VkImportFenceFdInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkImportFenceFdInfoKHR-fence-parameter", + "text": " fence must be a valid VkFence handle" + }, + { + "vuid": "VUID-VkImportFenceFdInfoKHR-flags-parameter", + "text": " flags must be a valid combination of VkFenceImportFlagBits values" + }, + { + "vuid": "VUID-VkImportFenceFdInfoKHR-handleType-parameter", + "text": " handleType must be a valid VkExternalFenceHandleTypeFlagBits value" + } + ] + }, + "vkCreateSemaphore": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateSemaphore-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "core": [ + { + "vuid": "VUID-vkCreateSemaphore-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateSemaphore-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkSemaphoreCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateSemaphore-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateSemaphore-pSemaphore-parameter", + "text": " pSemaphore must be a valid pointer to a VkSemaphore handle" + } + ] + }, + "VkSemaphoreCreateInfo": { + "core": [ + { + "vuid": "VUID-VkSemaphoreCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO" + }, + { + "vuid": "VUID-VkSemaphoreCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkExportSemaphoreCreateInfo or VkSemaphoreTypeCreateInfo" + }, + { + "vuid": "VUID-VkSemaphoreCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkSemaphoreCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + } + ] + }, + "VkSemaphoreTypeCreateInfo": { + "(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-VkSemaphoreTypeCreateInfo-timelineSemaphore-03252", + "text": " If the timelineSemaphore feature is not enabled, semaphoreType must not equal VK_SEMAPHORE_TYPE_TIMELINE" + }, + { + "vuid": "VUID-VkSemaphoreTypeCreateInfo-semaphoreType-03279", + "text": " If semaphoreType is VK_SEMAPHORE_TYPE_BINARY, initialValue must be zero" + }, + { + "vuid": "VUID-VkSemaphoreTypeCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO" + }, + { + "vuid": "VUID-VkSemaphoreTypeCreateInfo-semaphoreType-parameter", + "text": " semaphoreType must be a valid VkSemaphoreType value" + } + ] + }, + "VkExportSemaphoreCreateInfo": { + "(VK_VERSION_1_1,VK_KHR_external_semaphore)": [ + { + "vuid": "VUID-VkExportSemaphoreCreateInfo-handleTypes-01124", + "text": " The bits in handleTypes must be supported and compatible, as reported by VkExternalSemaphoreProperties" + }, + { + "vuid": "VUID-VkExportSemaphoreCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO" + }, + { + "vuid": "VUID-VkExportSemaphoreCreateInfo-handleTypes-parameter", + "text": " handleTypes must be a valid combination of VkExternalSemaphoreHandleTypeFlagBits values" + } + ] + }, + "VkExportSemaphoreWin32HandleInfoKHR": { + "(VK_KHR_external_semaphore_win32)": [ + { + "vuid": "VUID-VkExportSemaphoreWin32HandleInfoKHR-handleTypes-01125", + "text": " If VkExportSemaphoreCreateInfo::handleTypes does not include VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, VkExportSemaphoreWin32HandleInfoKHR must not be included in the pNext chain of VkSemaphoreCreateInfo" + } + ] + }, + "VkSemaphoreGetWin32HandleInfoKHR": { + "(VK_KHR_external_semaphore_win32)": [ + { + "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01126", + "text": " handleType must have been included in VkExportSemaphoreCreateInfo::handleTypes when the semaphore’s current payload was created" + }, + { + "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01127", + "text": " If handleType is defined as an NT handle, vkGetSemaphoreWin32HandleKHR must be called no more than once for each valid unique combination of semaphore and handleType" + }, + { + "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-semaphore-01128", + "text": " semaphore must not currently have its payload replaced by an imported payload as described below in Importing Semaphore Payloads unless that imported payload’s handle type was included in VkExternalSemaphoreProperties::exportFromImportedHandleTypes for handleType" + }, + { + "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01129", + "text": " If handleType refers to a handle type with copy payload transference semantics, as defined below in Importing Semaphore Payloads, there must be no queue waiting on semaphore" + }, + { + "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01130", + "text": " If handleType refers to a handle type with copy payload transference semantics, semaphore must be signaled, or have an associated semaphore signal operation pending execution" + }, + { + "vuid": "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-01131", + "text": " handleType must be defined as an NT handle or a global share handle" + } + ] + }, + "vkGetSemaphoreFdKHR": { + "(VK_KHR_external_semaphore_fd)": [ + { + "vuid": "VUID-vkGetSemaphoreFdKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetSemaphoreFdKHR-pGetFdInfo-parameter", + "text": " pGetFdInfo must be a valid pointer to a valid VkSemaphoreGetFdInfoKHR structure" + }, + { + "vuid": "VUID-vkGetSemaphoreFdKHR-pFd-parameter", + "text": " pFd must be a valid pointer to an int value" + } + ] + }, + "VkSemaphoreGetFdInfoKHR": { + "(VK_KHR_external_semaphore_fd)": [ + { + "vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-01132", + "text": " handleType must have been included in VkExportSemaphoreCreateInfo::handleTypes when semaphore’s current payload was created" + }, + { + "vuid": "VUID-VkSemaphoreGetFdInfoKHR-semaphore-01133", + "text": " semaphore must not currently have its payload replaced by an imported payload as described below in Importing Semaphore Payloads unless that imported payload’s handle type was included in VkExternalSemaphoreProperties::exportFromImportedHandleTypes for handleType" + }, + { + "vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-01134", + "text": " If handleType refers to a handle type with copy payload transference semantics, as defined below in Importing Semaphore Payloads, there must be no queue waiting on semaphore" + }, + { + "vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-01135", + "text": " If handleType refers to a handle type with copy payload transference semantics, semaphore must be signaled, or have an associated semaphore signal operation pending execution" + }, + { + "vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-01136", + "text": " handleType must be defined as a POSIX file descriptor handle" + }, + { + "vuid": "VUID-VkSemaphoreGetFdInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR" + }, + { + "vuid": "VUID-VkSemaphoreGetFdInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkSemaphoreGetFdInfoKHR-semaphore-parameter", + "text": " semaphore must be a valid VkSemaphore handle" + }, + { + "vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-parameter", + "text": " handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value" + } + ], + "(VK_KHR_external_semaphore_fd)+(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-03253", + "text": " If handleType refers to a handle type with copy payload transference semantics, semaphore must have been created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_BINARY" + }, + { + "vuid": "VUID-VkSemaphoreGetFdInfoKHR-handleType-03254", + "text": " If handleType refers to a handle type with copy payload transference semantics, semaphore must have an associated semaphore signal operation that has been submitted for execution and any semaphore signal operations on which it depends (if any) must have also been submitted for execution" + } + ] + }, + "VkSemaphoreGetZirconHandleInfoFUCHSIA": { + "(VK_FUCHSIA_external_semaphore)": [ + { + "vuid": "VUID-VkSemaphoreGetZirconHandleInfoFUCHSIA-handleType-04758", + "text": " handleType must have been included in VkExportSemaphoreCreateInfo::handleTypes when semaphore’s current payload was created" + }, + { + "vuid": "VUID-VkSemaphoreGetZirconHandleInfoFUCHSIA-semaphore-04759", + "text": " semaphore must not currently have its payload replaced by an imported payload as described below in Importing Semaphore Payloads unless that imported payload’s handle type was included in VkExternalSemaphoreProperties::exportFromImportedHandleTypes for handleType" + }, + { + "vuid": "VUID-VkSemaphoreGetZirconHandleInfoFUCHSIA-handleType-04760", + "text": " If handleType refers to a handle type with copy payload transference semantics, as defined below in Importing Semaphore Payloads, there must be no queue waiting on semaphore" + }, + { + "vuid": "VUID-VkSemaphoreGetZirconHandleInfoFUCHSIA-handleType-04761", + "text": " If handleType refers to a handle type with copy payload transference semantics, semaphore must be signaled, or have an associated semaphore signal operation pending execution" + }, + { + "vuid": "VUID-VkSemaphoreGetZirconHandleInfoFUCHSIA-handleType-04762", + "text": " handleType must be defined as a Zircon event handle" + }, + { + "vuid": "VUID-VkSemaphoreGetZirconHandleInfoFUCHSIA-semaphore-04763", + "text": " semaphore must have been created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_BINARY" + } + ] + }, + "vkDestroySemaphore": { + "core": [ + { + "vuid": "VUID-vkDestroySemaphore-semaphore-01137", + "text": " All submitted batches that refer to semaphore must have completed execution" + }, + { + "vuid": "VUID-vkDestroySemaphore-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroySemaphore-semaphore-parameter", + "text": " If semaphore is not VK_NULL_HANDLE, semaphore must be a valid VkSemaphore handle" + }, + { + "vuid": "VUID-vkDestroySemaphore-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroySemaphore-semaphore-parent", + "text": " If semaphore is a valid handle, it must have been created, allocated, or retrieved from device" + } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroySemaphore-semaphore-01138", + "text": " If VkAllocationCallbacks were provided when semaphore was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroySemaphore-semaphore-01139", + "text": " If no VkAllocationCallbacks were provided when semaphore was created, pAllocator must be NULL" + } + ] + }, + "vkGetSemaphoreCounterValue": { + "(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-vkGetSemaphoreCounterValue-semaphore-03255", + "text": " semaphore must have been created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE" + }, + { + "vuid": "VUID-vkGetSemaphoreCounterValue-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetSemaphoreCounterValue-semaphore-parameter", + "text": " semaphore must be a valid VkSemaphore handle" + }, + { + "vuid": "VUID-vkGetSemaphoreCounterValue-pValue-parameter", + "text": " pValue must be a valid pointer to a uint64_t value" + }, + { + "vuid": "VUID-vkGetSemaphoreCounterValue-semaphore-parent", + "text": " semaphore must have been created, allocated, or retrieved from device" + } + ] + }, + "vkWaitSemaphores": { + "(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-vkWaitSemaphores-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkWaitSemaphores-pWaitInfo-parameter", + "text": " pWaitInfo must be a valid pointer to a valid VkSemaphoreWaitInfo structure" + } + ] + }, + "VkSemaphoreWaitInfo": { + "(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-VkSemaphoreWaitInfo-pSemaphores-03256", + "text": " All of the elements of pSemaphores must reference a semaphore that was created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE" + }, + { + "vuid": "VUID-VkSemaphoreWaitInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO" + }, + { + "vuid": "VUID-VkSemaphoreWaitInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkSemaphoreWaitInfo-flags-parameter", + "text": " flags must be a valid combination of VkSemaphoreWaitFlagBits values" + }, + { + "vuid": "VUID-VkSemaphoreWaitInfo-pSemaphores-parameter", + "text": " pSemaphores must be a valid pointer to an array of semaphoreCount valid VkSemaphore handles" + }, + { + "vuid": "VUID-VkSemaphoreWaitInfo-pValues-parameter", + "text": " pValues must be a valid pointer to an array of semaphoreCount uint64_t values" + }, + { + "vuid": "VUID-VkSemaphoreWaitInfo-semaphoreCount-arraylength", + "text": " semaphoreCount must be greater than 0" + } + ] + }, + "vkSignalSemaphore": { + "(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-vkSignalSemaphore-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkSignalSemaphore-pSignalInfo-parameter", + "text": " pSignalInfo must be a valid pointer to a valid VkSemaphoreSignalInfo structure" + } + ] + }, + "VkSemaphoreSignalInfo": { + "(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-VkSemaphoreSignalInfo-semaphore-03257", + "text": " semaphore must have been created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE" + }, + { + "vuid": "VUID-VkSemaphoreSignalInfo-value-03258", + "text": " value must have a value greater than the current value of the semaphore" + }, + { + "vuid": "VUID-VkSemaphoreSignalInfo-value-03259", + "text": " value must be less than the value of any pending semaphore signal operations" + }, + { + "vuid": "VUID-VkSemaphoreSignalInfo-value-03260", + "text": " value must have a value which does not differ from the current value of the semaphore or the value of any outstanding semaphore wait or signal operation on semaphore by more than maxTimelineSemaphoreValueDifference" + }, + { + "vuid": "VUID-VkSemaphoreSignalInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO" + }, + { + "vuid": "VUID-VkSemaphoreSignalInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkSemaphoreSignalInfo-semaphore-parameter", + "text": " semaphore must be a valid VkSemaphore handle" + } + ] + }, + "VkImportSemaphoreWin32HandleInfoKHR": { + "(VK_KHR_external_semaphore_win32)": [ + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01140", + "text": " handleType must be a value included in the Handle Types Supported by VkImportSemaphoreWin32HandleInfoKHR table" + }, + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01466", + "text": " If handleType is not VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, name must be NULL" + }, + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01467", + "text": " If handle is NULL, name must name a valid synchronization primitive of the type specified by handleType" + }, + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01468", + "text": " If name is NULL, handle must be a valid handle of the type specified by handleType" + }, + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01469", + "text": " If handle is not NULL, name must be NULL" + }, + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01542", + "text": " If handle is not NULL, it must obey any requirements listed for handleType in external semaphore handle types compatibility" + }, + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-name-01543", + "text": " If name is not NULL, it must obey any requirements listed for handleType in external semaphore handle types compatibility" + }, + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-03261", + "text": " If handleType is VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, the VkSemaphoreCreateInfo::flags field must match that of the semaphore from which handle or name was exported" + } + ], + "(VK_KHR_external_semaphore_win32)+(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-03262", + "text": " If handleType is VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, the VkSemaphoreTypeCreateInfo::semaphoreType field must match that of the semaphore from which handle or name was exported" + }, + { + "vuid": "VUID-VkImportSemaphoreWin32HandleInfoKHR-flags-03322", + "text": " If flags contains VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, the VkSemaphoreTypeCreateInfo::semaphoreType field of the semaphore from which handle or name was exported must not be VK_SEMAPHORE_TYPE_TIMELINE" + } + ] + }, + "vkImportSemaphoreFdKHR": { + "(VK_KHR_external_semaphore_fd)": [ + { + "vuid": "VUID-vkImportSemaphoreFdKHR-semaphore-01142", + "text": " semaphore must not be associated with any queue command that has not yet completed execution on that queue" + }, + { + "vuid": "VUID-vkImportSemaphoreFdKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkImportSemaphoreFdKHR-pImportSemaphoreFdInfo-parameter", + "text": " pImportSemaphoreFdInfo must be a valid pointer to a valid VkImportSemaphoreFdInfoKHR structure" + } + ] + }, + "VkImportSemaphoreFdInfoKHR": { + "(VK_KHR_external_semaphore_fd)": [ + { + "vuid": "VUID-VkImportSemaphoreFdInfoKHR-handleType-01143", + "text": " handleType must be a value included in the Handle Types Supported by VkImportSemaphoreFdInfoKHR table" + }, + { + "vuid": "VUID-VkImportSemaphoreFdInfoKHR-fd-01544", + "text": " fd must obey any requirements listed for handleType in external semaphore handle types compatibility" + }, + { + "vuid": "VUID-VkImportSemaphoreFdInfoKHR-handleType-03263", + "text": " If handleType is VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, the VkSemaphoreCreateInfo::flags field must match that of the semaphore from which fd was exported" + }, + { + "vuid": "VUID-VkImportSemaphoreFdInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR" + }, + { + "vuid": "VUID-VkImportSemaphoreFdInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkImportSemaphoreFdInfoKHR-semaphore-parameter", + "text": " semaphore must be a valid VkSemaphore handle" + }, + { + "vuid": "VUID-VkImportSemaphoreFdInfoKHR-flags-parameter", + "text": " flags must be a valid combination of VkSemaphoreImportFlagBits values" + }, + { + "vuid": "VUID-VkImportSemaphoreFdInfoKHR-handleType-parameter", + "text": " handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value" + } + ], + "(VK_KHR_external_semaphore_fd)+(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-VkImportSemaphoreFdInfoKHR-handleType-03264", + "text": " If handleType is VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, the VkSemaphoreTypeCreateInfo::semaphoreType field must match that of the semaphore from which fd was exported" + }, + { + "vuid": "VUID-VkImportSemaphoreFdInfoKHR-flags-03323", + "text": " If flags contains VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, the VkSemaphoreTypeCreateInfo::semaphoreType field of the semaphore from which fd was exported must not be VK_SEMAPHORE_TYPE_TIMELINE" + } + ] + }, + "vkImportSemaphoreZirconHandleFUCHSIA": { + "(VK_FUCHSIA_external_semaphore)": [ + { + "vuid": "VUID-vkImportSemaphoreZirconHandleFUCHSIA-semaphore-04764", + "text": " semaphore must not be associated with any queue command that has not yet completed execution on that queue" + } + ] + }, + "VkImportSemaphoreZirconHandleInfoFUCHSIA": { + "(VK_FUCHSIA_external_semaphore)": [ + { + "vuid": "VUID-VkImportSemaphoreZirconHandleInfoFUCHSIA-handleType-04765", + "text": " handleType must be a value included in the Handle Types Supported by VkImportSemaphoreZirconHandleInfoFUCHSIA table" + }, + { + "vuid": "VUID-VkImportSemaphoreZirconHandleInfoFUCHSIA-zirconHandle-04766", + "text": " zirconHandle must obey any requirements listed for handleType in external semaphore handle types compatibility" + }, + { + "vuid": "VUID-VkImportSemaphoreZirconHandleInfoFUCHSIA-zirconHandle-04767", + "text": " zirconHandle must have ZX_RIGHTS_BASIC and ZX_RIGHTS_SIGNAL rights" + } + ], + "(VK_FUCHSIA_external_semaphore)+(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-VkImportSemaphoreZirconHandleInfoFUCHSIA-semaphoreType-04768", + "text": " The VkSemaphoreTypeCreateInfo::semaphoreType field must not be VK_SEMAPHORE_TYPE_TIMELINE" + } + ] + }, + "vkCreateEvent": { + "(VK_KHR_portability_subset)": [ + { + "vuid": "VUID-vkCreateEvent-events-04468", + "text": " If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::events is VK_FALSE, then the implementation does not support events, and vkCreateEvent must not be used" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateEvent-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "core": [ + { + "vuid": "VUID-vkCreateEvent-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateEvent-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkEventCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateEvent-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateEvent-pEvent-parameter", + "text": " pEvent must be a valid pointer to a VkEvent handle" + } + ] + }, + "VkEventCreateInfo": { + "core": [ + { + "vuid": "VUID-VkEventCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO" + }, + { + "vuid": "VUID-VkEventCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkEventCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkEventCreateFlagBits values" + } + ] + }, + "vkDestroyEvent": { + "core": [ + { + "vuid": "VUID-vkDestroyEvent-event-01145", + "text": " All submitted commands that refer to event must have completed execution" + }, + { + "vuid": "VUID-vkDestroyEvent-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyEvent-event-parameter", + "text": " If event is not VK_NULL_HANDLE, event must be a valid VkEvent handle" + }, + { + "vuid": "VUID-vkDestroyEvent-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyEvent-event-parent", + "text": " If event is a valid handle, it must have been created, allocated, or retrieved from device" + } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyEvent-event-01146", + "text": " If VkAllocationCallbacks were provided when event was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyEvent-event-01147", + "text": " If no VkAllocationCallbacks were provided when event was created, pAllocator must be NULL" + } + ] + }, + "vkGetEventStatus": { + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkGetEventStatus-event-03940", + "text": " event must not have been created with VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR" + } + ], + "core": [ + { + "vuid": "VUID-vkGetEventStatus-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetEventStatus-event-parameter", + "text": " event must be a valid VkEvent handle" + }, + { + "vuid": "VUID-vkGetEventStatus-event-parent", + "text": " event must have been created, allocated, or retrieved from device" + } + ] + }, + "vkSetEvent": { + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkSetEvent-event-03941", + "text": " event must not have been created with VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR" + } + ], + "core": [ + { + "vuid": "VUID-vkSetEvent-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkSetEvent-event-parameter", + "text": " event must be a valid VkEvent handle" + }, + { + "vuid": "VUID-vkSetEvent-event-parent", + "text": " event must have been created, allocated, or retrieved from device" + } + ] + }, + "vkResetEvent": { + "core": [ + { + "vuid": "VUID-vkResetEvent-event-03821", + "text": " There must be an execution dependency between vkResetEvent and the execution of any vkCmdWaitEvents that includes event in its pEvents parameter" + }, + { + "vuid": "VUID-vkResetEvent-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkResetEvent-event-parameter", + "text": " event must be a valid VkEvent handle" + }, + { + "vuid": "VUID-vkResetEvent-event-parent", + "text": " event must have been created, allocated, or retrieved from device" + } + ], + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkResetEvent-event-03822", + "text": " There must be an execution dependency between vkResetEvent and the execution of any vkCmdWaitEvents2KHR that includes event in its pEvents parameter" + }, + { + "vuid": "VUID-vkResetEvent-event-03823", + "text": " event must not have been created with VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR" + } + ] + }, + "vkCmdSetEvent2KHR": { + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkCmdSetEvent2KHR-synchronization2-03824", + "text": " The synchronization2 feature must be enabled" + }, + { + "vuid": "VUID-vkCmdSetEvent2KHR-dependencyFlags-03825", + "text": " The dependencyFlags member of pDependencyInfo must be 0" + }, + { + "vuid": "VUID-vkCmdSetEvent2KHR-srcStageMask-03827", + "text": " The srcStageMask member of any element of the pMemoryBarriers, pBufferMemoryBarriers, or pImageMemoryBarriers members of pDependencyInfo must only include pipeline stages valid for the queue family that was used to create the command pool that commandBuffer was allocated from" + }, + { + "vuid": "VUID-vkCmdSetEvent2KHR-dstStageMask-03828", + "text": " The dstStageMask member of any element of the pMemoryBarriers, pBufferMemoryBarriers, or pImageMemoryBarriers members of pDependencyInfo must only include pipeline stages valid for the queue family that was used to create the command pool that commandBuffer was allocated from" + }, + { + "vuid": "VUID-vkCmdSetEvent2KHR-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetEvent2KHR-event-parameter", + "text": " event must be a valid VkEvent handle" + }, + { + "vuid": "VUID-vkCmdSetEvent2KHR-pDependencyInfo-parameter", + "text": " pDependencyInfo must be a valid pointer to a valid VkDependencyInfoKHR structure" + }, + { + "vuid": "VUID-vkCmdSetEvent2KHR-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetEvent2KHR-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdSetEvent2KHR-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdSetEvent2KHR-commonparent", + "text": " Both of commandBuffer, and event must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_KHR_synchronization2)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkCmdSetEvent2KHR-commandBuffer-03826", + "text": " The current device mask of commandBuffer must include exactly one physical device" + } + ] + }, + "VkDependencyInfoKHR": { + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-VkDependencyInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR" + }, + { + "vuid": "VUID-VkDependencyInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDependencyInfoKHR-dependencyFlags-parameter", + "text": " dependencyFlags must be a valid combination of VkDependencyFlagBits values" + }, + { + "vuid": "VUID-VkDependencyInfoKHR-pMemoryBarriers-parameter", + "text": " If memoryBarrierCount is not 0, pMemoryBarriers must be a valid pointer to an array of memoryBarrierCount valid VkMemoryBarrier2KHR structures" + }, + { + "vuid": "VUID-VkDependencyInfoKHR-pBufferMemoryBarriers-parameter", + "text": " If bufferMemoryBarrierCount is not 0, pBufferMemoryBarriers must be a valid pointer to an array of bufferMemoryBarrierCount valid VkBufferMemoryBarrier2KHR structures" + }, + { + "vuid": "VUID-VkDependencyInfoKHR-pImageMemoryBarriers-parameter", + "text": " If imageMemoryBarrierCount is not 0, pImageMemoryBarriers must be a valid pointer to an array of imageMemoryBarrierCount valid VkImageMemoryBarrier2KHR structures" + } + ] + }, + "vkCmdSetEvent": { + "core": [ + { + "vuid": "VUID-vkCmdSetEvent-stageMask-04090", + "text": " If the geometry shaders feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdSetEvent-stageMask-04091", + "text": " If the tessellation shaders feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdSetEvent-stageMask-06457", + "text": " Any pipeline stage included in stageMask must be supported by the capabilities of the queue family specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool that commandBuffer was allocated from, as specified in the table of supported pipeline stages" + }, + { + "vuid": "VUID-vkCmdSetEvent-stageMask-01149", + "text": " stageMask must not include VK_PIPELINE_STAGE_HOST_BIT" + }, + { + "vuid": "VUID-vkCmdSetEvent-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetEvent-event-parameter", + "text": " event must be a valid VkEvent handle" + }, + { + "vuid": "VUID-vkCmdSetEvent-stageMask-parameter", + "text": " stageMask must be a valid combination of VkPipelineStageFlagBits values" + }, + { + "vuid": "VUID-vkCmdSetEvent-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetEvent-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdSetEvent-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdSetEvent-commonparent", + "text": " Both of commandBuffer, and event must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_EXT_conditional_rendering)": [ + { + "vuid": "VUID-vkCmdSetEvent-stageMask-04092", + "text": " If the conditional rendering feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT" + } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdSetEvent-stageMask-04093", + "text": " If the fragment density map feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + } + ], + "(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdSetEvent-stageMask-04094", + "text": " If the transform feedback feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT" + } + ], + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdSetEvent-stageMask-04095", + "text": " If the mesh shaders feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV" + }, + { + "vuid": "VUID-vkCmdSetEvent-stageMask-04096", + "text": " If the task shaders feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV" + } + ], + "(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdSetEvent-stageMask-04097", + "text": " If the shading rate image feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV" + } + ], + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkCmdSetEvent-stageMask-03937", + "text": " If the synchronization2 feature is not enabled, pname:stageMask must not be 0" + } + ], + "!(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkCmdSetEvent-stageMask-04996", + "text": " pname:stageMask must not be 0" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkCmdSetEvent-commandBuffer-01152", + "text": " commandBuffer’s current device mask must include exactly one physical device" + } + ] + }, + "vkCmdResetEvent2KHR": { + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkCmdResetEvent2KHR-stageMask-03929", + "text": " If the geometry shaders feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdResetEvent2KHR-stageMask-03930", + "text": " If the tessellation shaders feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR or VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdResetEvent2KHR-synchronization2-03829", + "text": " The synchronization2 feature must be enabled" + }, + { + "vuid": "VUID-vkCmdResetEvent2KHR-stageMask-03830", + "text": " stageMask must not include VK_PIPELINE_STAGE_2_HOST_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdResetEvent2KHR-event-03831", + "text": " There must be an execution dependency between vkCmdResetEvent2KHR and the execution of any vkCmdWaitEvents that includes event in its pEvents parameter" + }, + { + "vuid": "VUID-vkCmdResetEvent2KHR-event-03832", + "text": " There must be an execution dependency between vkCmdResetEvent2KHR and the execution of any vkCmdWaitEvents2KHR that includes event in its pEvents parameter" + }, + { + "vuid": "VUID-vkCmdResetEvent2KHR-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdResetEvent2KHR-event-parameter", + "text": " event must be a valid VkEvent handle" + }, + { + "vuid": "VUID-vkCmdResetEvent2KHR-stageMask-parameter", + "text": " stageMask must be a valid combination of VkPipelineStageFlagBits2KHR values" + }, + { + "vuid": "VUID-vkCmdResetEvent2KHR-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdResetEvent2KHR-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdResetEvent2KHR-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdResetEvent2KHR-commonparent", + "text": " Both of commandBuffer, and event must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_KHR_synchronization2)+(VK_EXT_conditional_rendering)": [ + { + "vuid": "VUID-vkCmdResetEvent2KHR-stageMask-03931", + "text": " If the conditional rendering feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT" + } + ], + "(VK_KHR_synchronization2)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdResetEvent2KHR-stageMask-03932", + "text": " If the fragment density map feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + } + ], + "(VK_KHR_synchronization2)+(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdResetEvent2KHR-stageMask-03933", + "text": " If the transform feedback feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT" + } + ], + "(VK_KHR_synchronization2)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdResetEvent2KHR-stageMask-03934", + "text": " If the mesh shaders feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV" + }, + { + "vuid": "VUID-vkCmdResetEvent2KHR-stageMask-03935", + "text": " If the task shaders feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV" + } + ], + "(VK_KHR_synchronization2)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdResetEvent2KHR-stageMask-04956", + "text": " If the shading rate image feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV" + } + ], + "(VK_KHR_synchronization2)+(VK_HUAWEI_subpass_shading)": [ + { + "vuid": "VUID-vkCmdResetEvent2KHR-stageMask-04957", + "text": " If the subpass shading feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI" + } + ], + "(VK_KHR_synchronization2)+(VK_HUAWEI_invocation_mask)": [ + { + "vuid": "VUID-vkCmdResetEvent2KHR-stageMask-04995", + "text": " If the invocation mask image feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI" + } + ], + "(VK_KHR_synchronization2)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkCmdResetEvent2KHR-commandBuffer-03833", + "text": " commandBuffer’s current device mask must include exactly one physical device" + } + ] + }, + "vkCmdResetEvent": { + "core": [ + { + "vuid": "VUID-vkCmdResetEvent-stageMask-04090", + "text": " If the geometry shaders feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdResetEvent-stageMask-04091", + "text": " If the tessellation shaders feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdResetEvent-stageMask-06458", + "text": " Any pipeline stage included in stageMask must be supported by the capabilities of the queue family specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool that commandBuffer was allocated from, as specified in the table of supported pipeline stages" + }, + { + "vuid": "VUID-vkCmdResetEvent-stageMask-01153", + "text": " stageMask must not include VK_PIPELINE_STAGE_HOST_BIT" + }, + { + "vuid": "VUID-vkCmdResetEvent-event-03834", + "text": " There must be an execution dependency between vkCmdResetEvent and the execution of any vkCmdWaitEvents that includes event in its pEvents parameter" + }, + { + "vuid": "VUID-vkCmdResetEvent-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdResetEvent-event-parameter", + "text": " event must be a valid VkEvent handle" + }, + { + "vuid": "VUID-vkCmdResetEvent-stageMask-parameter", + "text": " stageMask must be a valid combination of VkPipelineStageFlagBits values" + }, + { + "vuid": "VUID-vkCmdResetEvent-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdResetEvent-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdResetEvent-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdResetEvent-commonparent", + "text": " Both of commandBuffer, and event must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_EXT_conditional_rendering)": [ + { + "vuid": "VUID-vkCmdResetEvent-stageMask-04092", + "text": " If the conditional rendering feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT" + } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdResetEvent-stageMask-04093", + "text": " If the fragment density map feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + } + ], + "(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdResetEvent-stageMask-04094", + "text": " If the transform feedback feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT" + } + ], + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdResetEvent-stageMask-04095", + "text": " If the mesh shaders feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV" + }, + { + "vuid": "VUID-vkCmdResetEvent-stageMask-04096", + "text": " If the task shaders feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV" + } + ], + "(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdResetEvent-stageMask-04097", + "text": " If the shading rate image feature is not enabled, pname:stageMask must not contain VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV" + } + ], + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkCmdResetEvent-stageMask-03937", + "text": " If the synchronization2 feature is not enabled, pname:stageMask must not be 0" + }, + { + "vuid": "VUID-vkCmdResetEvent-event-03835", + "text": " There must be an execution dependency between vkCmdResetEvent and the execution of any vkCmdWaitEvents2KHR that includes event in its pEvents parameter" + } + ], + "!(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkCmdResetEvent-stageMask-04996", + "text": " pname:stageMask must not be 0" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkCmdResetEvent-commandBuffer-01157", + "text": " commandBuffer’s current device mask must include exactly one physical device" + } + ] + }, + "vkCmdWaitEvents2KHR": { + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkCmdWaitEvents2KHR-synchronization2-03836", + "text": " The synchronization2 feature must be enabled" + }, + { + "vuid": "VUID-vkCmdWaitEvents2KHR-pEvents-03837", + "text": " Members of pEvents must not have been signaled by vkCmdSetEvent" + }, + { + "vuid": "VUID-vkCmdWaitEvents2KHR-pEvents-03838", + "text": " For any element i of pEvents, if that event is signaled by vkCmdSetEvent2KHR, that command’s dependencyInfo parameter must be exactly equal to the ith element of pDependencyInfos" + }, + { + "vuid": "VUID-vkCmdWaitEvents2KHR-pEvents-03839", + "text": " For any element i of pEvents, if that event is signaled by vkSetEvent, barriers in the ith element of pDependencyInfos must include only host operations in their first synchronization scope" + }, + { + "vuid": "VUID-vkCmdWaitEvents2KHR-pEvents-03840", + "text": " For any element i of pEvents, if barriers in the ith element of pDependencyInfos include only host operations, the ith element of pEvents must be signaled before vkCmdWaitEvents2KHR is executed" + }, + { + "vuid": "VUID-vkCmdWaitEvents2KHR-pEvents-03841", + "text": " For any element i of pEvents, if barriers in the ith element of pDependencyInfos do not include host operations, the ith element of pEvents must be signaled by a corresponding vkCmdSetEvent2KHR that occurred earlier in submission order" + }, + { + "vuid": "VUID-vkCmdWaitEvents2KHR-srcStageMask-03842", + "text": " The srcStageMask member of any element of the pMemoryBarriers, pBufferMemoryBarriers, or pImageMemoryBarriers members of pDependencyInfos must either include only pipeline stages valid for the queue family that was used to create the command pool that commandBuffer was allocated from, or include only VK_PIPELINE_STAGE_2_HOST_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdWaitEvents2KHR-dstStageMask-03843", + "text": " The dstStageMask member of any element of the pMemoryBarriers, pBufferMemoryBarriers, or pImageMemoryBarriers members of pDependencyInfos must only include pipeline stages valid for the queue family that was used to create the command pool that commandBuffer was allocated from" + }, + { + "vuid": "VUID-vkCmdWaitEvents2KHR-dependencyFlags-03844", + "text": " The dependencyFlags member of any element of pDependencyInfo must be 0" + }, + { + "vuid": "VUID-vkCmdWaitEvents2KHR-pEvents-03845", + "text": " If pEvents includes one or more events that will be signaled by vkSetEvent after commandBuffer has been submitted to a queue, then vkCmdWaitEvents2KHR must not be called inside a render pass instance" + }, + { + "vuid": "VUID-vkCmdWaitEvents2KHR-commandBuffer-03846", + "text": " commandBuffer’s current device mask must include exactly one physical device" + }, + { + "vuid": "VUID-vkCmdWaitEvents2KHR-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdWaitEvents2KHR-pEvents-parameter", + "text": " pEvents must be a valid pointer to an array of eventCount valid VkEvent handles" + }, + { + "vuid": "VUID-vkCmdWaitEvents2KHR-pDependencyInfos-parameter", + "text": " pDependencyInfos must be a valid pointer to an array of eventCount valid VkDependencyInfoKHR structures" + }, + { + "vuid": "VUID-vkCmdWaitEvents2KHR-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdWaitEvents2KHR-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdWaitEvents2KHR-eventCount-arraylength", + "text": " eventCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdWaitEvents2KHR-commonparent", + "text": " Both of commandBuffer, and the elements of pEvents must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "vkCmdWaitEvents": { + "core": [ + { + "vuid": "VUID-vkCmdWaitEvents-srcStageMask-04090", + "text": " If the geometry shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdWaitEvents-srcStageMask-04091", + "text": " If the tessellation shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdWaitEvents-dstStageMask-04090", + "text": " If the geometry shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdWaitEvents-dstStageMask-04091", + "text": " If the tessellation shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdWaitEvents-srcAccessMask-02815", + "text": " The srcAccessMask member of each element of pMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-vkCmdWaitEvents-dstAccessMask-02816", + "text": " The dstAccessMask member of each element of pMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-vkCmdWaitEvents-pBufferMemoryBarriers-02817", + "text": " For any element of pBufferMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its srcQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its srcAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-vkCmdWaitEvents-pBufferMemoryBarriers-02818", + "text": " For any element of pBufferMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its dstQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its dstAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-vkCmdWaitEvents-pImageMemoryBarriers-02819", + "text": " For any element of pImageMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its srcQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its srcAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-vkCmdWaitEvents-pImageMemoryBarriers-02820", + "text": " For any element of pImageMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its dstQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its dstAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-vkCmdWaitEvents-srcStageMask-06459", + "text": " Any pipeline stage included in srcStageMask must be supported by the capabilities of the queue family specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool that commandBuffer was allocated from, as specified in the table of supported pipeline stages" + }, + { + "vuid": "VUID-vkCmdWaitEvents-dstStageMask-06460", + "text": " Any pipeline stage included in dstStageMask must be supported by the capabilities of the queue family specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool that commandBuffer was allocated from, as specified in the table of supported pipeline stages" + }, + { + "vuid": "VUID-vkCmdWaitEvents-srcStageMask-01158", + "text": " srcStageMask must be the bitwise OR of the stageMask parameter used in previous calls to vkCmdSetEvent with any of the elements of pEvents and VK_PIPELINE_STAGE_HOST_BIT if any of the elements of pEvents was set using vkSetEvent" + }, + { + "vuid": "VUID-vkCmdWaitEvents-pEvents-01163", + "text": " If pEvents includes one or more events that will be signaled by vkSetEvent after commandBuffer has been submitted to a queue, then vkCmdWaitEvents must not be called inside a render pass instance" + }, + { + "vuid": "VUID-vkCmdWaitEvents-srcQueueFamilyIndex-02803", + "text": " The srcQueueFamilyIndex and dstQueueFamilyIndex members of any element of pBufferMemoryBarriers or pImageMemoryBarriers must be equal" + }, + { + "vuid": "VUID-vkCmdWaitEvents-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdWaitEvents-pEvents-parameter", + "text": " pEvents must be a valid pointer to an array of eventCount valid VkEvent handles" + }, + { + "vuid": "VUID-vkCmdWaitEvents-srcStageMask-parameter", + "text": " srcStageMask must be a valid combination of VkPipelineStageFlagBits values" + }, + { + "vuid": "VUID-vkCmdWaitEvents-dstStageMask-parameter", + "text": " dstStageMask must be a valid combination of VkPipelineStageFlagBits values" + }, + { + "vuid": "VUID-vkCmdWaitEvents-pMemoryBarriers-parameter", + "text": " If memoryBarrierCount is not 0, pMemoryBarriers must be a valid pointer to an array of memoryBarrierCount valid VkMemoryBarrier structures" + }, + { + "vuid": "VUID-vkCmdWaitEvents-pBufferMemoryBarriers-parameter", + "text": " If bufferMemoryBarrierCount is not 0, pBufferMemoryBarriers must be a valid pointer to an array of bufferMemoryBarrierCount valid VkBufferMemoryBarrier structures" + }, + { + "vuid": "VUID-vkCmdWaitEvents-pImageMemoryBarriers-parameter", + "text": " If imageMemoryBarrierCount is not 0, pImageMemoryBarriers must be a valid pointer to an array of imageMemoryBarrierCount valid VkImageMemoryBarrier structures" + }, + { + "vuid": "VUID-vkCmdWaitEvents-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdWaitEvents-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdWaitEvents-eventCount-arraylength", + "text": " eventCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdWaitEvents-commonparent", + "text": " Both of commandBuffer, and the elements of pEvents must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_EXT_conditional_rendering)": [ + { + "vuid": "VUID-vkCmdWaitEvents-srcStageMask-04092", + "text": " If the conditional rendering feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdWaitEvents-dstStageMask-04092", + "text": " If the conditional rendering feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT" + } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdWaitEvents-srcStageMask-04093", + "text": " If the fragment density map feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdWaitEvents-dstStageMask-04093", + "text": " If the fragment density map feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + } + ], + "(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdWaitEvents-srcStageMask-04094", + "text": " If the transform feedback feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdWaitEvents-dstStageMask-04094", + "text": " If the transform feedback feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT" + } + ], + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdWaitEvents-srcStageMask-04095", + "text": " If the mesh shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV" + }, + { + "vuid": "VUID-vkCmdWaitEvents-srcStageMask-04096", + "text": " If the task shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV" + }, + { + "vuid": "VUID-vkCmdWaitEvents-dstStageMask-04095", + "text": " If the mesh shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV" + }, + { + "vuid": "VUID-vkCmdWaitEvents-dstStageMask-04096", + "text": " If the task shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV" + } + ], + "(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdWaitEvents-srcStageMask-04097", + "text": " If the shading rate image feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV" + }, + { + "vuid": "VUID-vkCmdWaitEvents-dstStageMask-04097", + "text": " If the shading rate image feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV" + } + ], + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkCmdWaitEvents-srcStageMask-03937", + "text": " If the synchronization2 feature is not enabled, pname:srcStageMask must not be 0" + }, + { + "vuid": "VUID-vkCmdWaitEvents-dstStageMask-03937", + "text": " If the synchronization2 feature is not enabled, pname:dstStageMask must not be 0" + }, + { + "vuid": "VUID-vkCmdWaitEvents-pEvents-03847", + "text": " Elements of pEvents must not have been signaled by vkCmdSetEvent2KHR" + } + ], + "!(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkCmdWaitEvents-srcStageMask-04996", + "text": " pname:srcStageMask must not be 0" + }, + { + "vuid": "VUID-vkCmdWaitEvents-dstStageMask-04996", + "text": " pname:dstStageMask must not be 0" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkCmdWaitEvents-commandBuffer-01167", + "text": " commandBuffer’s current device mask must include exactly one physical device" + } + ] + }, + "vkCmdPipelineBarrier2KHR": { + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkCmdPipelineBarrier2KHR-pDependencies-02285", + "text": " If fname:vkCmdPipelineBarrier2KHR is called within a render pass instance, the render pass must have been created with at least one VkSubpassDependency instance in VkRenderPassCreateInfo::pDependencies that expresses a dependency from the current subpass to itself, with synchronization scopes and access scopes that are all supersets of the scopes defined in this command" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier2KHR-bufferMemoryBarrierCount-01178", + "text": " If fname:vkCmdPipelineBarrier2KHR is called within a render pass instance, it must not include any buffer memory barriers" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier2KHR-image-04073", + "text": " If fname:vkCmdPipelineBarrier2KHR is called within a render pass instance, the image member of any image memory barrier included in this command must be an attachment used in the current subpass both as an input attachment, and as either a color or depth/stencil attachment" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier2KHR-oldLayout-01181", + "text": " If fname:vkCmdPipelineBarrier2KHR is called within a render pass instance, the oldLayout and newLayout members of any image memory barrier included in this command must be equal" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier2KHR-srcQueueFamilyIndex-01182", + "text": " If fname:vkCmdPipelineBarrier2KHR is called within a render pass instance, the srcQueueFamilyIndex and dstQueueFamilyIndex members of any image memory barrier included in this command must be equal" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier2KHR-synchronization2-03848", + "text": " The synchronization2 feature must be enabled" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier2KHR-srcStageMask-03849", + "text": " The srcStageMask member of any element of the pMemoryBarriers, pBufferMemoryBarriers, or pImageMemoryBarriers members of pDependencyInfo must only include pipeline stages valid for the queue family that was used to create the command pool that commandBuffer was allocated from" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier2KHR-dstStageMask-03850", + "text": " The dstStageMask member of any element of the pMemoryBarriers, pBufferMemoryBarriers, or pImageMemoryBarriers members of pDependencyInfo must only include pipeline stages valid for the queue family that was used to create the command pool that commandBuffer was allocated from" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier2KHR-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier2KHR-pDependencyInfo-parameter", + "text": " pDependencyInfo must be a valid pointer to a valid VkDependencyInfoKHR structure" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier2KHR-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier2KHR-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + } + ], + "(VK_KHR_synchronization2)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdPipelineBarrier2KHR-dependencyFlags-01186", + "text": " If fname:vkCmdPipelineBarrier2KHR is called outside of a render pass instance, VK_DEPENDENCY_VIEW_LOCAL_BIT must not be included in the dependency flags" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdPipelineBarrier2KHR-None-06191", + "text": " If fname:vkCmdPipelineBarrier2KHR is called within a render pass instance, the render pass must not have been started with vkCmdBeginRenderingKHR" + } + ] + }, + "vkCmdPipelineBarrier": { + "core": [ + { + "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-04090", + "text": " If the geometry shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-04091", + "text": " If the tessellation shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-04090", + "text": " If the geometry shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-04091", + "text": " If the tessellation shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-srcAccessMask-02815", + "text": " The srcAccessMask member of each element of pMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dstAccessMask-02816", + "text": " The dstAccessMask member of each element of pMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-02817", + "text": " For any element of pBufferMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its srcQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its srcAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-02818", + "text": " For any element of pBufferMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its dstQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its dstAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-pImageMemoryBarriers-02819", + "text": " For any element of pImageMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its srcQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its srcAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-pImageMemoryBarriers-02820", + "text": " For any element of pImageMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its dstQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its dstAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-pDependencies-02285", + "text": " If fname:vkCmdPipelineBarrier is called within a render pass instance, the render pass must have been created with at least one VkSubpassDependency instance in VkRenderPassCreateInfo::pDependencies that expresses a dependency from the current subpass to itself, with synchronization scopes and access scopes that are all supersets of the scopes defined in this command" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-bufferMemoryBarrierCount-01178", + "text": " If fname:vkCmdPipelineBarrier is called within a render pass instance, it must not include any buffer memory barriers" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-image-04073", + "text": " If fname:vkCmdPipelineBarrier is called within a render pass instance, the image member of any image memory barrier included in this command must be an attachment used in the current subpass both as an input attachment, and as either a color or depth/stencil attachment" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-oldLayout-01181", + "text": " If fname:vkCmdPipelineBarrier is called within a render pass instance, the oldLayout and newLayout members of any image memory barrier included in this command must be equal" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-srcQueueFamilyIndex-01182", + "text": " If fname:vkCmdPipelineBarrier is called within a render pass instance, the srcQueueFamilyIndex and dstQueueFamilyIndex members of any image memory barrier included in this command must be equal" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-06461", + "text": " Any pipeline stage included in srcStageMask must be supported by the capabilities of the queue family specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool that commandBuffer was allocated from, as specified in the table of supported pipeline stages" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-06462", + "text": " Any pipeline stage included in dstStageMask must be supported by the capabilities of the queue family specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool that commandBuffer was allocated from, as specified in the table of supported pipeline stages" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-parameter", + "text": " srcStageMask must be a valid combination of VkPipelineStageFlagBits values" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-parameter", + "text": " dstStageMask must be a valid combination of VkPipelineStageFlagBits values" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dependencyFlags-parameter", + "text": " dependencyFlags must be a valid combination of VkDependencyFlagBits values" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-pMemoryBarriers-parameter", + "text": " If memoryBarrierCount is not 0, pMemoryBarriers must be a valid pointer to an array of memoryBarrierCount valid VkMemoryBarrier structures" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-parameter", + "text": " If bufferMemoryBarrierCount is not 0, pBufferMemoryBarriers must be a valid pointer to an array of bufferMemoryBarrierCount valid VkBufferMemoryBarrier structures" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-pImageMemoryBarriers-parameter", + "text": " If imageMemoryBarrierCount is not 0, pImageMemoryBarriers must be a valid pointer to an array of imageMemoryBarrierCount valid VkImageMemoryBarrier structures" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + } + ], + "(VK_EXT_conditional_rendering)": [ + { + "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-04092", + "text": " If the conditional rendering feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-04092", + "text": " If the conditional rendering feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT" + } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-04093", + "text": " If the fragment density map feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-04093", + "text": " If the fragment density map feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + } + ], + "(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-04094", + "text": " If the transform feedback feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-04094", + "text": " If the transform feedback feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT" + } + ], + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-04095", + "text": " If the mesh shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-04096", + "text": " If the task shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-04095", + "text": " If the mesh shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-04096", + "text": " If the task shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV" + } + ], + "(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-04097", + "text": " If the shading rate image feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-04097", + "text": " If the shading rate image feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV" + } + ], + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-03937", + "text": " If the synchronization2 feature is not enabled, pname:srcStageMask must not be 0" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-03937", + "text": " If the synchronization2 feature is not enabled, pname:dstStageMask must not be 0" + } + ], + "!(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-04996", + "text": " pname:srcStageMask must not be 0" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-04996", + "text": " pname:dstStageMask must not be 0" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdPipelineBarrier-dependencyFlags-01186", + "text": " If fname:vkCmdPipelineBarrier is called outside of a render pass instance, VK_DEPENDENCY_VIEW_LOCAL_BIT must not be included in the dependency flags" + } + ], + "(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdPipelineBarrier-None-06191", + "text": " If fname:vkCmdPipelineBarrier is called within a render pass instance, the render pass must not have been started with vkCmdBeginRenderingKHR" + } + ] + }, + "VkMemoryBarrier2KHR": { + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcStageMask-03929", + "text": " If the geometry shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcStageMask-03930", + "text": " If the tessellation shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR or VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03900", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03901", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_INDEX_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03902", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03903", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR, VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03904", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_UNIFORM_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03905", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03906", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03907", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03908", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_SHADER_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03909", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_SHADER_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03910", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03911", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03912", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03913", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03914", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_TRANSFER_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_COPY_BIT_KHR, VK_PIPELINE_STAGE_2_BLIT_BIT_KHR, VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03915", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_COPY_BIT_KHR, VK_PIPELINE_STAGE_2_BLIT_BIT_KHR, VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR, VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03916", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_HOST_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_HOST_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03917", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_HOST_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_HOST_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstStageMask-03929", + "text": " If the geometry shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstStageMask-03930", + "text": " If the tessellation shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR or VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03900", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03901", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_INDEX_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03902", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03903", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR, VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03904", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_UNIFORM_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03905", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03906", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03907", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03908", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_SHADER_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03909", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_SHADER_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03910", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03911", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03912", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03913", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03914", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_TRANSFER_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_COPY_BIT_KHR, VK_PIPELINE_STAGE_2_BLIT_BIT_KHR, VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03915", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_COPY_BIT_KHR, VK_PIPELINE_STAGE_2_BLIT_BIT_KHR, VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR, VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03916", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_HOST_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_HOST_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03917", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_HOST_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_HOST_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcStageMask-parameter", + "text": " srcStageMask must be a valid combination of VkPipelineStageFlagBits2KHR values" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-parameter", + "text": " srcAccessMask must be a valid combination of VkAccessFlagBits2KHR values" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstStageMask-parameter", + "text": " dstStageMask must be a valid combination of VkPipelineStageFlagBits2KHR values" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-parameter", + "text": " dstAccessMask must be a valid combination of VkAccessFlagBits2KHR values" + } + ], + "(VK_KHR_synchronization2)+(VK_EXT_conditional_rendering)": [ + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcStageMask-03931", + "text": " If the conditional rendering feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03918", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT, pname:srcStageMask must include VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstStageMask-03931", + "text": " If the conditional rendering feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03918", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT, pname:dstStageMask must include VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcStageMask-03932", + "text": " If the fragment density map feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03919", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT, pname:srcStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstStageMask-03932", + "text": " If the fragment density map feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03919", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT, pname:dstStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcStageMask-03933", + "text": " If the transform feedback feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03920", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, pname:srcStageMask must include VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-04747", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT, pname:srcStageMask must include VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR, VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03922", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT, pname:srcStageMask must include VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstStageMask-03933", + "text": " If the transform feedback feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03920", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, pname:dstStageMask must include VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-04747", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT, pname:dstStageMask must include VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR, VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03922", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT, pname:dstStageMask must include VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcStageMask-03934", + "text": " If the mesh shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcStageMask-03935", + "text": " If the task shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstStageMask-03934", + "text": " If the mesh shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstStageMask-03935", + "text": " If the task shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV" + } + ], + "(VK_KHR_synchronization2)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcStageMask-04956", + "text": " If the shading rate image feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03923", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV, pname:srcStageMask must include VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstStageMask-04956", + "text": " If the shading rate image feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03923", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV, pname:dstStageMask must include VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_HUAWEI_subpass_shading)": [ + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcStageMask-04957", + "text": " If the subpass shading feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstStageMask-04957", + "text": " If the subpass shading feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI" + } + ], + "(VK_KHR_synchronization2)+(VK_HUAWEI_invocation_mask)": [ + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcStageMask-04995", + "text": " If the invocation mask image feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-04994", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI, pname:srcStageMask must include VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstStageMask-04995", + "text": " If the invocation mask image feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-04994", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI, pname:dstStageMask must include VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI" + } + ], + "(VK_KHR_synchronization2)+(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03924", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV, pname:srcStageMask must include VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03925", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV, pname:srcStageMask must include VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03924", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV, pname:dstStageMask must include VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03925", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV, pname:dstStageMask must include VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03926", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT, pname:srcStageMask must include VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03926", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT, pname:dstStageMask must include VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_acceleration_structure,VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03927", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-03928", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03927", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-03928", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_acceleration_structure,VK_NV_ray_tracing)+!(VK_KHR_ray_query)+(VK_KHR_ray_tracing_pipeline,VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-06254", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:srcStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages except VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-06254", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:dstStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages except VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_acceleration_structure,VK_NV_ray_tracing)+!(VK_KHR_ray_query)+!(VK_KHR_ray_tracing_pipeline,VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-06255", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:srcStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-06255", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:dstStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_acceleration_structure,VK_NV_ray_tracing)+(VK_KHR_ray_query)+(VK_KHR_ray_tracing_pipeline,VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-06256", + "text": " If rayQuery is not enabled and pname:srcAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:srcStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages except VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-06256", + "text": " If rayQuery is not enabled and pname:dstAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:dstStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages except VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_acceleration_structure,VK_NV_ray_tracing)+(VK_KHR_ray_query)+!(VK_KHR_ray_tracing_pipeline,VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-06257", + "text": " If rayQuery is not enabled and pname:srcAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:srcStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-06257", + "text": " If rayQuery is not enabled and pname:dstAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:dstStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_video_decode_queue)": [ + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-04858", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-04859", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-04858", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-04859", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_video_encode_queue)": [ + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-04860", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-srcAccessMask-04861", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-04860", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR" + }, + { + "vuid": "VUID-VkMemoryBarrier2KHR-dstAccessMask-04861", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR" + } + ] + }, + "VkMemoryBarrier": { + "core": [ + { + "vuid": "VUID-VkMemoryBarrier-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_BARRIER" + }, + { + "vuid": "VUID-VkMemoryBarrier-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkMemoryBarrier-srcAccessMask-parameter", + "text": " srcAccessMask must be a valid combination of VkAccessFlagBits values" + }, + { + "vuid": "VUID-VkMemoryBarrier-dstAccessMask-parameter", + "text": " dstAccessMask must be a valid combination of VkAccessFlagBits values" + } + ] + }, + "VkBufferMemoryBarrier2KHR": { + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcStageMask-03929", + "text": " If the geometry shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcStageMask-03930", + "text": " If the tessellation shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR or VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03900", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03901", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_INDEX_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03902", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03903", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR, VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03904", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_UNIFORM_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03905", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03906", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03907", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03908", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_SHADER_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03909", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_SHADER_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03910", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03911", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03912", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03913", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03914", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_TRANSFER_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_COPY_BIT_KHR, VK_PIPELINE_STAGE_2_BLIT_BIT_KHR, VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03915", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_COPY_BIT_KHR, VK_PIPELINE_STAGE_2_BLIT_BIT_KHR, VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR, VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03916", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_HOST_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_HOST_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03917", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_HOST_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_HOST_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstStageMask-03929", + "text": " If the geometry shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstStageMask-03930", + "text": " If the tessellation shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR or VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03900", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03901", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_INDEX_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03902", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03903", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR, VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03904", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_UNIFORM_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03905", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03906", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03907", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03908", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_SHADER_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03909", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_SHADER_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03910", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03911", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03912", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03913", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03914", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_TRANSFER_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_COPY_BIT_KHR, VK_PIPELINE_STAGE_2_BLIT_BIT_KHR, VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03915", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_COPY_BIT_KHR, VK_PIPELINE_STAGE_2_BLIT_BIT_KHR, VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR, VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03916", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_HOST_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_HOST_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03917", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_HOST_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_HOST_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-offset-01187", + "text": " offset must be less than the size of buffer" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-size-01188", + "text": " If size is not equal to VK_WHOLE_SIZE, size must be greater than 0" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-size-01189", + "text": " If size is not equal to VK_WHOLE_SIZE, size must be less than or equal to than the size of buffer minus offset" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-buffer-01931", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcStageMask-03851", + "text": " If either srcStageMask or dstStageMask includes VK_PIPELINE_STAGE_2_HOST_BIT_KHR, srcQueueFamilyIndex and dstQueueFamilyIndex must be equal" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcStageMask-parameter", + "text": " srcStageMask must be a valid combination of VkPipelineStageFlagBits2KHR values" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-parameter", + "text": " srcAccessMask must be a valid combination of VkAccessFlagBits2KHR values" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstStageMask-parameter", + "text": " dstStageMask must be a valid combination of VkPipelineStageFlagBits2KHR values" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-parameter", + "text": " dstAccessMask must be a valid combination of VkAccessFlagBits2KHR values" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + } + ], + "(VK_KHR_synchronization2)+(VK_EXT_conditional_rendering)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcStageMask-03931", + "text": " If the conditional rendering feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03918", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT, pname:srcStageMask must include VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstStageMask-03931", + "text": " If the conditional rendering feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03918", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT, pname:dstStageMask must include VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcStageMask-03932", + "text": " If the fragment density map feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03919", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT, pname:srcStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstStageMask-03932", + "text": " If the fragment density map feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03919", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT, pname:dstStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcStageMask-03933", + "text": " If the transform feedback feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03920", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, pname:srcStageMask must include VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-04747", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT, pname:srcStageMask must include VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR, VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03922", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT, pname:srcStageMask must include VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstStageMask-03933", + "text": " If the transform feedback feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03920", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, pname:dstStageMask must include VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-04747", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT, pname:dstStageMask must include VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR, VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03922", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT, pname:dstStageMask must include VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcStageMask-03934", + "text": " If the mesh shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcStageMask-03935", + "text": " If the task shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstStageMask-03934", + "text": " If the mesh shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstStageMask-03935", + "text": " If the task shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV" + } + ], + "(VK_KHR_synchronization2)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcStageMask-04956", + "text": " If the shading rate image feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03923", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV, pname:srcStageMask must include VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstStageMask-04956", + "text": " If the shading rate image feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03923", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV, pname:dstStageMask must include VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_HUAWEI_subpass_shading)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcStageMask-04957", + "text": " If the subpass shading feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstStageMask-04957", + "text": " If the subpass shading feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI" + } + ], + "(VK_KHR_synchronization2)+(VK_HUAWEI_invocation_mask)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcStageMask-04995", + "text": " If the invocation mask image feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-04994", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI, pname:srcStageMask must include VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstStageMask-04995", + "text": " If the invocation mask image feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-04994", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI, pname:dstStageMask must include VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI" + } + ], + "(VK_KHR_synchronization2)+(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03924", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV, pname:srcStageMask must include VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03925", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV, pname:srcStageMask must include VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03924", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV, pname:dstStageMask must include VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03925", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV, pname:dstStageMask must include VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03926", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT, pname:srcStageMask must include VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03926", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT, pname:dstStageMask must include VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_acceleration_structure,VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03927", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-03928", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03927", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-03928", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_acceleration_structure,VK_NV_ray_tracing)+!(VK_KHR_ray_query)+(VK_KHR_ray_tracing_pipeline,VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-06254", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:srcStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages except VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-06254", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:dstStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages except VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_acceleration_structure,VK_NV_ray_tracing)+!(VK_KHR_ray_query)+!(VK_KHR_ray_tracing_pipeline,VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-06255", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:srcStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-06255", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:dstStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_acceleration_structure,VK_NV_ray_tracing)+(VK_KHR_ray_query)+(VK_KHR_ray_tracing_pipeline,VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-06256", + "text": " If rayQuery is not enabled and pname:srcAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:srcStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages except VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-06256", + "text": " If rayQuery is not enabled and pname:dstAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:dstStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages except VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_acceleration_structure,VK_NV_ray_tracing)+(VK_KHR_ray_query)+!(VK_KHR_ray_tracing_pipeline,VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-06257", + "text": " If rayQuery is not enabled and pname:srcAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:srcStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-06257", + "text": " If rayQuery is not enabled and pname:dstAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:dstStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_video_decode_queue)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-04858", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-04859", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-04858", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-04859", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_video_encode_queue)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-04860", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcAccessMask-04861", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-04860", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-dstAccessMask-04861", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+!(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-buffer-04086", + "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not equal, srcQueueFamilyIndex and dstQueueFamilyIndex must be valid queue families" + } + ], + "(VK_KHR_synchronization2)+(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-srcQueueFamilyIndex-04087", + "text": " If srcQueueFamilyIndex is not equal to dstQueueFamilyIndex, at least one must not be a special queue family reserved for external memory ownership transfers, as described in Queue Family Ownership Transfer" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-buffer-04088", + "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, srcQueueFamilyIndex and dstQueueFamilyIndex are not equal, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is one of the special queue family values reserved for external memory transfers, the other must be VK_QUEUE_FAMILY_IGNORED" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2KHR-buffer-04089", + "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not equal, srcQueueFamilyIndex and dstQueueFamilyIndex must both be valid queue families, or one of the special queue family values reserved for external memory transfers, as described in Queue Family Ownership Transfer" + } + ] + }, + "VkBufferMemoryBarrier": { + "core": [ + { + "vuid": "VUID-VkBufferMemoryBarrier-offset-01187", + "text": " offset must be less than the size of buffer" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-size-01188", + "text": " If size is not equal to VK_WHOLE_SIZE, size must be greater than 0" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-size-01189", + "text": " If size is not equal to VK_WHOLE_SIZE, size must be less than or equal to than the size of buffer minus offset" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-buffer-01931", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + } + ], + "!(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier-buffer-04086", + "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not equal, srcQueueFamilyIndex and dstQueueFamilyIndex must be valid queue families" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-synchronization2-03852", + "text": " If the synchronization2 feature is not enabled, and buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, srcQueueFamilyIndex and dstQueueFamilyIndex must both be VK_QUEUE_FAMILY_IGNORED" + } + ], + "(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkBufferMemoryBarrier-srcQueueFamilyIndex-04087", + "text": " If srcQueueFamilyIndex is not equal to dstQueueFamilyIndex, at least one must not be a special queue family reserved for external memory ownership transfers, as described in Queue Family Ownership Transfer" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-buffer-04088", + "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, srcQueueFamilyIndex and dstQueueFamilyIndex are not equal, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is one of the special queue family values reserved for external memory transfers, the other must be VK_QUEUE_FAMILY_IGNORED" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-buffer-04089", + "text": " If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not equal, srcQueueFamilyIndex and dstQueueFamilyIndex must both be valid queue families, or one of the special queue family values reserved for external memory transfers, as described in Queue Family Ownership Transfer" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier-synchronization2-03853", + "text": " If the synchronization2 feature is not enabled, and buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, at least one of srcQueueFamilyIndex and dstQueueFamilyIndex must be VK_QUEUE_FAMILY_IGNORED" + } + ] + }, + "VkImageMemoryBarrier2KHR": { + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcStageMask-03929", + "text": " If the geometry shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcStageMask-03930", + "text": " If the tessellation shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR or VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03900", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03901", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_INDEX_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03902", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03903", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR, VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03904", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_UNIFORM_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03905", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03906", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03907", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03908", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_SHADER_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03909", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_SHADER_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03910", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03911", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03912", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03913", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03914", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_TRANSFER_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_COPY_BIT_KHR, VK_PIPELINE_STAGE_2_BLIT_BIT_KHR, VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03915", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_COPY_BIT_KHR, VK_PIPELINE_STAGE_2_BLIT_BIT_KHR, VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR, VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03916", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_HOST_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_HOST_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03917", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_HOST_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_HOST_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstStageMask-03929", + "text": " If the geometry shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstStageMask-03930", + "text": " If the tessellation shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR or VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03900", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03901", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_INDEX_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03902", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03903", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR, VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03904", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_UNIFORM_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03905", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03906", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03907", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03908", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_SHADER_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03909", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_SHADER_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03910", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03911", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03912", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03913", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03914", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_TRANSFER_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_COPY_BIT_KHR, VK_PIPELINE_STAGE_2_BLIT_BIT_KHR, VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03915", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_COPY_BIT_KHR, VK_PIPELINE_STAGE_2_BLIT_BIT_KHR, VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR, VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03916", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_HOST_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_HOST_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03917", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_HOST_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_HOST_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-subresourceRange-01486", + "text": " subresourceRange.baseMipLevel must be less than the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-subresourceRange-01724", + "text": " If subresourceRange.levelCount is not VK_REMAINING_MIP_LEVELS, subresourceRange.baseMipLevel + subresourceRange.levelCount must be less than or equal to the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-subresourceRange-01488", + "text": " subresourceRange.baseArrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-subresourceRange-01725", + "text": " If subresourceRange.layerCount is not VK_REMAINING_ARRAY_LAYERS, subresourceRange.baseArrayLayer + subresourceRange.layerCount must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-image-01932", + "text": " If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-oldLayout-01208", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-oldLayout-01209", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-oldLayout-01210", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-oldLayout-01211", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-oldLayout-01212", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-oldLayout-01213", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-oldLayout-01197", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, oldLayout must be VK_IMAGE_LAYOUT_UNDEFINED or the current layout of the image subresources affected by the barrier" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-newLayout-01198", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, newLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcStageMask-03854", + "text": " If either srcStageMask or dstStageMask includes VK_PIPELINE_STAGE_2_HOST_BIT_KHR, srcQueueFamilyIndex and dstQueueFamilyIndex must be equal" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcStageMask-03855", + "text": " If srcStageMask includes VK_PIPELINE_STAGE_2_HOST_BIT_KHR, and srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, oldLayout must be one of VK_IMAGE_LAYOUT_PREINITIALIZED, VK_IMAGE_LAYOUT_UNDEFINED, or VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkSampleLocationsInfoEXT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcStageMask-parameter", + "text": " srcStageMask must be a valid combination of VkPipelineStageFlagBits2KHR values" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-parameter", + "text": " srcAccessMask must be a valid combination of VkAccessFlagBits2KHR values" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstStageMask-parameter", + "text": " dstStageMask must be a valid combination of VkPipelineStageFlagBits2KHR values" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-parameter", + "text": " dstAccessMask must be a valid combination of VkAccessFlagBits2KHR values" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-oldLayout-parameter", + "text": " oldLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-newLayout-parameter", + "text": " newLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-image-parameter", + "text": " image must be a valid VkImage handle" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-subresourceRange-parameter", + "text": " subresourceRange must be a valid VkImageSubresourceRange structure" + } + ], + "(VK_KHR_synchronization2)+(VK_EXT_conditional_rendering)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcStageMask-03931", + "text": " If the conditional rendering feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03918", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT, pname:srcStageMask must include VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstStageMask-03931", + "text": " If the conditional rendering feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03918", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT, pname:dstStageMask must include VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcStageMask-03932", + "text": " If the fragment density map feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03919", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT, pname:srcStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstStageMask-03932", + "text": " If the fragment density map feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03919", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT, pname:dstStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcStageMask-03933", + "text": " If the transform feedback feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03920", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, pname:srcStageMask must include VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-04747", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT, pname:srcStageMask must include VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR, VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03922", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT, pname:srcStageMask must include VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstStageMask-03933", + "text": " If the transform feedback feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03920", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, pname:dstStageMask must include VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-04747", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT, pname:dstStageMask must include VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR, VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03922", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT, pname:dstStageMask must include VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcStageMask-03934", + "text": " If the mesh shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcStageMask-03935", + "text": " If the task shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstStageMask-03934", + "text": " If the mesh shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstStageMask-03935", + "text": " If the task shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV" + } + ], + "(VK_KHR_synchronization2)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcStageMask-04956", + "text": " If the shading rate image feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03923", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV, pname:srcStageMask must include VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstStageMask-04956", + "text": " If the shading rate image feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03923", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV, pname:dstStageMask must include VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_HUAWEI_subpass_shading)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcStageMask-04957", + "text": " If the subpass shading feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstStageMask-04957", + "text": " If the subpass shading feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI" + } + ], + "(VK_KHR_synchronization2)+(VK_HUAWEI_invocation_mask)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcStageMask-04995", + "text": " If the invocation mask image feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-04994", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI, pname:srcStageMask must include VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstStageMask-04995", + "text": " If the invocation mask image feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-04994", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI, pname:dstStageMask must include VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI" + } + ], + "(VK_KHR_synchronization2)+(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03924", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV, pname:srcStageMask must include VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03925", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV, pname:srcStageMask must include VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03924", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV, pname:dstStageMask must include VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03925", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV, pname:dstStageMask must include VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03926", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT, pname:srcStageMask must include VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03926", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT, pname:dstStageMask must include VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_acceleration_structure,VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03927", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-03928", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03927", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-03928", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_acceleration_structure,VK_NV_ray_tracing)+!(VK_KHR_ray_query)+(VK_KHR_ray_tracing_pipeline,VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-06254", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:srcStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages except VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-06254", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:dstStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages except VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_acceleration_structure,VK_NV_ray_tracing)+!(VK_KHR_ray_query)+!(VK_KHR_ray_tracing_pipeline,VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-06255", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:srcStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-06255", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:dstStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_acceleration_structure,VK_NV_ray_tracing)+(VK_KHR_ray_query)+(VK_KHR_ray_tracing_pipeline,VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-06256", + "text": " If rayQuery is not enabled and pname:srcAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:srcStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages except VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-06256", + "text": " If rayQuery is not enabled and pname:dstAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:dstStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages except VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_acceleration_structure,VK_NV_ray_tracing)+(VK_KHR_ray_query)+!(VK_KHR_ray_tracing_pipeline,VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-06257", + "text": " If rayQuery is not enabled and pname:srcAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:srcStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-06257", + "text": " If rayQuery is not enabled and pname:dstAccessMask includes VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, pname:dstStageMask must not include any of the VK_PIPELINE_STAGE_*_SHADER_BIT stages" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_video_decode_queue)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-04858", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-04859", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-04858", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-04859", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_video_encode_queue)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-04860", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcAccessMask-04861", + "text": " If pname:srcAccessMask includes VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR, pname:srcStageMask must include VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-04860", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-dstAccessMask-04861", + "text": " If pname:dstAccessMask includes VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR, pname:dstStageMask must include VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR" + } + ], + "(VK_KHR_synchronization2)+(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-oldLayout-01658", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-oldLayout-01659", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + } + ], + "(VK_KHR_synchronization2)+(VK_VERSION_1_2,VK_EXT_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcQueueFamilyIndex-04065", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL then image must have been created with at least one of VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_SAMPLED_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcQueueFamilyIndex-04066", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcQueueFamilyIndex-04067", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then image must have been created with at least one of VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_SAMPLED_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcQueueFamilyIndex-04068", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcQueueFamilyIndex-03938", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR, image must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT or VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcQueueFamilyIndex-03939", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR, image must have been created with at least one of VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_SAMPLED_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT" + } + ], + "(VK_KHR_synchronization2)+(VK_KHR_fragment_shading_rate,VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-oldLayout-02088", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR then image must have been created with VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR set" + } + ], + "(VK_KHR_synchronization2)+!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-image-02902", + "text": " If image has a color format, then the aspectMask member of subresourceRange must be VK_IMAGE_ASPECT_COLOR_BIT" + } + ], + "(VK_KHR_synchronization2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-image-01671", + "text": " If image has a single-plane color format or is not disjoint, then the aspectMask member of subresourceRange must be VK_IMAGE_ASPECT_COLOR_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-image-01672", + "text": " If image has a multi-planar format and the image is disjoint, then the aspectMask member of subresourceRange must include either at least one of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, and VK_IMAGE_ASPECT_PLANE_2_BIT; or must include VK_IMAGE_ASPECT_COLOR_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-image-01673", + "text": " If image has a multi-planar format with only two planes, then the aspectMask member of subresourceRange must not include VK_IMAGE_ASPECT_PLANE_2_BIT" + } + ], + "(VK_KHR_synchronization2)+!(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-image-01207", + "text": " If image has a depth/stencil format with both depth and stencil components, then the aspectMask member of subresourceRange must include both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT" + } + ], + "(VK_KHR_synchronization2)+(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-image-03319", + "text": " If image has a depth/stencil format with both depth and stencil and the separateDepthStencilLayouts feature is enabled, then the aspectMask member of subresourceRange must include either or both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-image-03320", + "text": " If image has a depth/stencil format with both depth and stencil and the separateDepthStencilLayouts feature is not enabled, then the aspectMask member of subresourceRange must include both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT" + } + ], + "(VK_KHR_synchronization2)+!(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-image-04069", + "text": " If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not equal, srcQueueFamilyIndex and dstQueueFamilyIndex must be valid queue families" + } + ], + "(VK_KHR_synchronization2)+(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-srcQueueFamilyIndex-04070", + "text": " If srcQueueFamilyIndex is not equal to dstQueueFamilyIndex, at least one must not be a special queue family reserved for external memory ownership transfers, as described in Queue Family Ownership Transfer" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-image-04071", + "text": " If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, srcQueueFamilyIndex and dstQueueFamilyIndex are not equal, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is one of the special queue family values reserved for external memory transfers, the other must be VK_QUEUE_FAMILY_IGNORED" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2KHR-image-04072", + "text": " If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not equal, srcQueueFamilyIndex and dstQueueFamilyIndex must both be valid queue families, or one of the special queue family values reserved for external memory transfers, as described in Queue Family Ownership Transfer" + } + ] + }, + "VkImageMemoryBarrier": { + "core": [ + { + "vuid": "VUID-VkImageMemoryBarrier-subresourceRange-01486", + "text": " subresourceRange.baseMipLevel must be less than the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-subresourceRange-01724", + "text": " If subresourceRange.levelCount is not VK_REMAINING_MIP_LEVELS, subresourceRange.baseMipLevel + subresourceRange.levelCount must be less than or equal to the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-subresourceRange-01488", + "text": " subresourceRange.baseArrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-subresourceRange-01725", + "text": " If subresourceRange.layerCount is not VK_REMAINING_ARRAY_LAYERS, subresourceRange.baseArrayLayer + subresourceRange.layerCount must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-image-01932", + "text": " If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01208", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01209", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01210", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01211", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01212", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01213", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01197", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, oldLayout must be VK_IMAGE_LAYOUT_UNDEFINED or the current layout of the image subresources affected by the barrier" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-newLayout-01198", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, newLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkSampleLocationsInfoEXT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-oldLayout-parameter", + "text": " oldLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-newLayout-parameter", + "text": " newLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-image-parameter", + "text": " image must be a valid VkImage handle" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-subresourceRange-parameter", + "text": " subresourceRange must be a valid VkImageSubresourceRange structure" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01658", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-oldLayout-01659", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + } + ], + "(VK_VERSION_1_2,VK_EXT_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-VkImageMemoryBarrier-srcQueueFamilyIndex-04065", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL then image must have been created with at least one of VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_SAMPLED_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-srcQueueFamilyIndex-04066", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-srcQueueFamilyIndex-04067", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then image must have been created with at least one of VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_SAMPLED_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-srcQueueFamilyIndex-04068", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set" + } + ], + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-VkImageMemoryBarrier-srcQueueFamilyIndex-03938", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR, image must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT or VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-srcQueueFamilyIndex-03939", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR, image must have been created with at least one of VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_SAMPLED_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT" + } + ], + "(VK_KHR_fragment_shading_rate,VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkImageMemoryBarrier-oldLayout-02088", + "text": " If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR then image must have been created with VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR set" + } + ], + "!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageMemoryBarrier-image-02902", + "text": " If image has a color format, then the aspectMask member of subresourceRange must be VK_IMAGE_ASPECT_COLOR_BIT" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageMemoryBarrier-image-01671", + "text": " If image has a single-plane color format or is not disjoint, then the aspectMask member of subresourceRange must be VK_IMAGE_ASPECT_COLOR_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-image-01672", + "text": " If image has a multi-planar format and the image is disjoint, then the aspectMask member of subresourceRange must include either at least one of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, and VK_IMAGE_ASPECT_PLANE_2_BIT; or must include VK_IMAGE_ASPECT_COLOR_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-image-01673", + "text": " If image has a multi-planar format with only two planes, then the aspectMask member of subresourceRange must not include VK_IMAGE_ASPECT_PLANE_2_BIT" + } + ], + "!(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-VkImageMemoryBarrier-image-01207", + "text": " If image has a depth/stencil format with both depth and stencil components, then the aspectMask member of subresourceRange must include both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT" + } + ], + "(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-VkImageMemoryBarrier-image-03319", + "text": " If image has a depth/stencil format with both depth and stencil and the separateDepthStencilLayouts feature is enabled, then the aspectMask member of subresourceRange must include either or both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-image-03320", + "text": " If image has a depth/stencil format with both depth and stencil and the separateDepthStencilLayouts feature is not enabled, then the aspectMask member of subresourceRange must include both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT" + } + ], + "!(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkImageMemoryBarrier-image-04069", + "text": " If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not equal, srcQueueFamilyIndex and dstQueueFamilyIndex must be valid queue families" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-synchronization2-03856", + "text": " If the synchronization2 feature is not enabled, and image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, srcQueueFamilyIndex and dstQueueFamilyIndex must both be VK_QUEUE_FAMILY_IGNORED" + } + ], + "(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkImageMemoryBarrier-srcQueueFamilyIndex-04070", + "text": " If srcQueueFamilyIndex is not equal to dstQueueFamilyIndex, at least one must not be a special queue family reserved for external memory ownership transfers, as described in Queue Family Ownership Transfer" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-image-04071", + "text": " If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, srcQueueFamilyIndex and dstQueueFamilyIndex are not equal, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is one of the special queue family values reserved for external memory transfers, the other must be VK_QUEUE_FAMILY_IGNORED" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-image-04072", + "text": " If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not equal, srcQueueFamilyIndex and dstQueueFamilyIndex must both be valid queue families, or one of the special queue family values reserved for external memory transfers, as described in Queue Family Ownership Transfer" + }, + { + "vuid": "VUID-VkImageMemoryBarrier-synchronization2-03857", + "text": " If the synchronization2 feature is not enabled, and image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, at least one of srcQueueFamilyIndex and dstQueueFamilyIndex must be VK_QUEUE_FAMILY_IGNORED" + } + ] + }, + "vkQueueWaitIdle": { + "core": [ + { + "vuid": "VUID-vkQueueWaitIdle-queue-parameter", + "text": " queue must be a valid VkQueue handle" + } + ] + }, + "vkDeviceWaitIdle": { + "core": [ + { + "vuid": "VUID-vkDeviceWaitIdle-device-parameter", + "text": " device must be a valid VkDevice handle" + } + ] + }, + "vkGetCalibratedTimestampsEXT": { + "(VK_EXT_calibrated_timestamps)": [ + { + "vuid": "VUID-vkGetCalibratedTimestampsEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetCalibratedTimestampsEXT-pTimestampInfos-parameter", + "text": " pTimestampInfos must be a valid pointer to an array of timestampCount valid VkCalibratedTimestampInfoEXT structures" + }, + { + "vuid": "VUID-vkGetCalibratedTimestampsEXT-pTimestamps-parameter", + "text": " pTimestamps must be a valid pointer to an array of timestampCount uint64_t values" + }, + { + "vuid": "VUID-vkGetCalibratedTimestampsEXT-pMaxDeviation-parameter", + "text": " pMaxDeviation must be a valid pointer to a uint64_t value" + }, + { + "vuid": "VUID-vkGetCalibratedTimestampsEXT-timestampCount-arraylength", + "text": " timestampCount must be greater than 0" + } + ] + }, + "VkCalibratedTimestampInfoEXT": { + "(VK_EXT_calibrated_timestamps)": [ + { + "vuid": "VUID-VkCalibratedTimestampInfoEXT-timeDomain-02354", + "text": " timeDomain must be one of the VkTimeDomainEXT values returned by vkGetPhysicalDeviceCalibrateableTimeDomainsEXT" + }, + { + "vuid": "VUID-VkCalibratedTimestampInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT" + }, + { + "vuid": "VUID-VkCalibratedTimestampInfoEXT-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkCalibratedTimestampInfoEXT-timeDomain-parameter", + "text": " timeDomain must be a valid VkTimeDomainEXT value" + } + ] + }, + "vkCmdBeginRenderingKHR": { + "(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdBeginRenderingKHR-dynamicRendering-06446", + "text": " The dynamicRendering feature must be enabled" + }, + { + "vuid": "VUID-vkCmdBeginRenderingKHR-commandBuffer-06068", + "text": " If commandBuffer is a secondary command buffer, pRenderingInfo->flags must not include VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR" + } + ] + }, + "VkRenderingInfoKHR": { + "(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-VkRenderingInfoKHR-viewMask-06069", + "text": " If viewMask is 0, layerCount must not be 0" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-imageView-06070", + "text": " If neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, imageView members of pDepthAttachment, pStencilAttachment, and elements of pColorAttachments that are not VK_NULL_HANDLE must have been created with the same sampleCount" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-colorAttachmentCount-06087", + "text": " If colorAttachmentCount is not 0 and the imageView member of an element of pColorAttachments is not VK_NULL_HANDLE, that imageView must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pDepthAttachment-06088", + "text": " If pDepthAttachment is not NULL and pDepthAttachment->imageView is not VK_NULL_HANDLE, pDepthAttachment->imageView must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pStencilAttachment-06089", + "text": " If pStencilAttachment is not NULL and pStencilAttachment->imageView is not VK_NULL_HANDLE, pStencilAttachment->imageView must have been created with a stencil usage including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-colorAttachmentCount-06090", + "text": " If colorAttachmentCount is not 0 and the imageView member of an element of pColorAttachments is not VK_NULL_HANDLE, the layout member of that element of pColorAttachments must not be VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-colorAttachmentCount-06091", + "text": " If colorAttachmentCount is not 0 and the imageView member of an element of pColorAttachments is not VK_NULL_HANDLE, if the resolveMode member of that element of pColorAttachments is not VK_RESOLVE_MODE_NONE, its resolveImageLayout member must not be VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pDepthAttachment-06092", + "text": " If pDepthAttachment is not NULL and pDepthAttachment->imageView is not VK_NULL_HANDLE, pDepthAttachment->layout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pDepthAttachment-06093", + "text": " If pDepthAttachment is not NULL, pDepthAttachment->imageView is not VK_NULL_HANDLE, and pDepthAttachment->resolveMode is not VK_RESOLVE_MODE_NONE, pDepthAttachment->resolveImageLayout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pStencilAttachment-06094", + "text": " If pStencilAttachment is not NULL and pStencilAttachment->imageView is not VK_NULL_HANDLE, pStencilAttachment->layout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pStencilAttachment-06095", + "text": " If pStencilAttachment is not NULL, pStencilAttachment->imageView is not VK_NULL_HANDLE, and pStencilAttachment->resolveMode is not VK_RESOLVE_MODE_NONE, pStencilAttachment->resolveImageLayout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-colorAttachmentCount-06106", + "text": " colorAttachmentCount must be less than or equal to VkPhysicalDeviceLimits::maxColorAttachments" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-multiview-06127", + "text": " If the multiview feature is not enabled, viewMask must be 0" + } + ], + "(VK_KHR_dynamic_rendering)+!(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkRenderingInfoKHR-renderArea-06071", + "text": " renderArea.offset.x must be greater than or equal to 0" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-renderArea-06072", + "text": " renderArea.offset.y must be greater than or equal to 0" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-renderArea-06073", + "text": " The sum of renderArea.offset.x and renderArea.extent.width must be less than or equal to maxFramebufferWidth" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-renderArea-06074", + "text": " The sum of renderArea.offset.y and renderArea.extent.height must be less than or equal to maxFramebufferHeight" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-imageView-06075", + "text": " The width of the imageView member of any element of pColorAttachments, pDepthAttachment, or pStencilAttachment that is not VK_NULL_HANDLE must be greater than or equal to renderArea.offset.x + renderArea.extent.width" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-imageView-06076", + "text": " The height of the imageView member of any element of pColorAttachments, pDepthAttachment, or pStencilAttachment that is not VK_NULL_HANDLE must be greater than or equal to renderArea.offset.y + renderArea.extent.height" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkRenderingInfoKHR-pNext-06077", + "text": " If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0, renderArea.offset.x must be greater than or equal to 0" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pNext-06078", + "text": " If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0, renderArea.offset.y must be greater than or equal to 0" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pNext-06079", + "text": " If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0, the width of the imageView member of any element of pColorAttachments, pDepthAttachment, or pStencilAttachment that is not VK_NULL_HANDLE must be greater than or equal to renderArea.offset.x + renderArea.extent.width" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pNext-06080", + "text": " If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0, the height of the imageView member of any element of pColorAttachments, pDepthAttachment, or pStencilAttachment that is not VK_NULL_HANDLE must be greater than or equal to renderArea.offset.y + renderArea.extent.height" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pNext-06083", + "text": " If the pNext chain contains VkDeviceGroupRenderPassBeginInfo, the width of the imageView member of any element of pColorAttachments, pDepthAttachment, or pStencilAttachment that is not VK_NULL_HANDLE must be greater than or equal to the sum of the offset.x and extent.width members of each element of pDeviceRenderAreas" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pNext-06084", + "text": " If the pNext chain contains VkDeviceGroupRenderPassBeginInfo, the height of the imageView member of any element of pColorAttachments, pDepthAttachment, or pStencilAttachment that is not VK_NULL_HANDLE must be greater than or equal to the sum of the offset.y and extent.height members of each element of pDeviceRenderAreas" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pDepthAttachment-06085", + "text": " If neither pDepthAttachment or pStencilAttachment are NULL and the imageView member of either structure is not VK_NULL_HANDLE, the imageView member of each structure must be the same" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pDepthAttachment-06086", + "text": " If neither pDepthAttachment or pStencilAttachment are NULL, and the resolveMode member of each is not VK_RESOLVE_MODE_NONE, the resolveImageView member of each structure must be the same" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_KHR_maintenance2,VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkRenderingInfoKHR-colorAttachmentCount-06096", + "text": " If colorAttachmentCount is not 0 and the imageView member of an element of pColorAttachments is not VK_NULL_HANDLE, the layout member of that element of pColorAttachments must not be VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-colorAttachmentCount-06097", + "text": " If colorAttachmentCount is not 0 and the imageView member of an element of pColorAttachments is not VK_NULL_HANDLE, if the resolveMode member of that element of pColorAttachments is not VK_RESOLVE_MODE_NONE, its resolveImageLayout member must not be VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pDepthAttachment-06098", + "text": " If pDepthAttachment is not NULL, pDepthAttachment->imageView is not VK_NULL_HANDLE, and pDepthAttachment->resolveMode is not VK_RESOLVE_MODE_NONE, pDepthAttachment->resolveImageLayout must not be VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pStencilAttachment-06099", + "text": " If pStencilAttachment is not NULL, pStencilAttachment->imageView is not VK_NULL_HANDLE, and pStencilAttachment->resolveMode is not VK_RESOLVE_MODE_NONE, pStencilAttachment->resolveImageLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_KHR_separate_depth_stencil_layouts,VK_VERSION_1_2)": [ + { + "vuid": "VUID-VkRenderingInfoKHR-colorAttachmentCount-06100", + "text": " If colorAttachmentCount is not 0 and the imageView member of an element of pColorAttachments is not VK_NULL_HANDLE, the layout member of that element of pColorAttachments must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-colorAttachmentCount-06101", + "text": " If colorAttachmentCount is not 0 and the imageView member of an element of pColorAttachments is not VK_NULL_HANDLE, if the resolveMode member of that element of pColorAttachments is not VK_RESOLVE_MODE_NONE, its resolveImageLayout member must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_KHR_depth_stencil_resolve,VK_VERSION_1_2)": [ + { + "vuid": "VUID-VkRenderingInfoKHR-pDepthAttachment-06102", + "text": " If pDepthAttachment is not NULL and pDepthAttachment->imageView is not VK_NULL_HANDLE, pDepthAttachment->resolveMode must be one of the bits set in VkPhysicalDeviceDepthStencilResolveProperties::supportedDepthResolveModes" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pStencilAttachment-06103", + "text": " If pStencilAttachment is not NULL and pStencilAttachment->imageView is not VK_NULL_HANDLE, pStencilAttachment->resolveMode must be one of the bits set in VkPhysicalDeviceDepthStencilResolveProperties::supportedStencilResolveModes" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pDepthAttachment-06104", + "text": " If pDepthAttachment or pStencilAttachment are both not NULL, pDepthAttachment->imageView and pStencilAttachment->imageView are both not VK_NULL_HANDLE, and VkPhysicalDeviceDepthStencilResolveProperties::independentResolveNone is VK_FALSE, the resolveMode of both structures must be the same value" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pDepthAttachment-06105", + "text": " If pDepthAttachment or pStencilAttachment are both not NULL, pDepthAttachment->imageView and pStencilAttachment->imageView are both not VK_NULL_HANDLE, VkPhysicalDeviceDepthStencilResolveProperties::independentResolve is VK_FALSE, and the resolveMode of neither structure is VK_RESOLVE_MODE_NONE, the resolveMode of both structures must be the same value" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkRenderingInfoKHR-imageView-06107", + "text": " If the imageView member of a VkRenderingFragmentDensityMapAttachmentInfoEXT structure included in the pNext chain is not VK_NULL_HANDLE, and non-subsample image feature is not enabled, valid imageView and resolveImageView members of pDepthAttachment, pStencilAttachment, and each element of pColorAttachments must be a VkImageView created with VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-imageView-06116", + "text": " If the imageView member of a VkRenderingFragmentDensityMapAttachmentInfoEXT structure included in the pNext chain is not VK_NULL_HANDLE, it must not be equal to the imageView or resolveImageView member of pDepthAttachment, pStencilAttachment, or any element of pColorAttachments" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkRenderingInfoKHR-imageView-06108", + "text": " If the imageView member of a VkRenderingFragmentDensityMapAttachmentInfoEXT structure included in the pNext chain is not VK_NULL_HANDLE, and viewMask is not 0, imageView must have a layerCount greater than or equal to the index of the most significant bit in viewMask" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-imageView-06109", + "text": " If the imageView member of a VkRenderingFragmentDensityMapAttachmentInfoEXT structure included in the pNext chain is not VK_NULL_HANDLE, and viewMask is 0, imageView must have a layerCount equal to 1" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)+!(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkRenderingInfoKHR-imageView-06110", + "text": " If the imageView member of a VkRenderingFragmentDensityMapAttachmentInfoEXT structure included in the pNext chain is not VK_NULL_HANDLE, imageView must have a width greater than or equal to \\(\\left\\lceil{\\frac{renderArea_{x}+renderArea_{width}}{maxFragmentDensityTexelSize_{width}}}\\right\\rceil\\)" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-imageView-06111", + "text": " If the imageView member of a VkRenderingFragmentDensityMapAttachmentInfoEXT structure included in the pNext chain is not VK_NULL_HANDLE, imageView must have a height greater than or equal to \\(\\left\\lceil{\\frac{renderArea_{y}+renderArea_{height}}{maxFragmentDensityTexelSize_{height}}}\\right\\rceil\\)" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkRenderingInfoKHR-pNext-06112", + "text": " If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0 and the imageView member of a VkRenderingFragmentDensityMapAttachmentInfoEXT structure included in the pNext chain is not VK_NULL_HANDLE, imageView must have a width greater than or equal to \\(\\left\\lceil{\\frac{renderArea_{x}+renderArea_{width}}{maxFragmentDensityTexelSize_{width}}}\\right\\rceil\\)" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pNext-06113", + "text": " If the pNext chain contains a VkDeviceGroupRenderPassBeginInfo structure, its deviceRenderAreaCount member is not 0, and the imageView member of a VkRenderingFragmentDensityMapAttachmentInfoEXT structure included in the pNext chain is not VK_NULL_HANDLE, imageView must have a width greater than or equal to \\(\\left\\lceil{\\frac{pDeviceRenderAreas_{x}+pDeviceRenderAreas_{width}}{maxFragmentDensityTexelSize_{width}}}\\right\\rceil\\) for each element of pDeviceRenderAreas" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pNext-06114", + "text": " If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0 and the imageView member of a VkRenderingFragmentDensityMapAttachmentInfoEXT structure included in the pNext chain is not VK_NULL_HANDLE, imageView must have a height greater than or equal to \\(\\left\\lceil{\\frac{renderArea_{y}+renderArea_{height}}{maxFragmentDensityTexelSize_{height}}}\\right\\rceil\\)" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pNext-06115", + "text": " If the pNext chain contains a VkDeviceGroupRenderPassBeginInfo structure, its deviceRenderAreaCount member is not 0, and the imageView member of a VkRenderingFragmentDensityMapAttachmentInfoEXT structure included in the pNext chain is not VK_NULL_HANDLE, imageView must have a height greater than or equal to \\(\\left\\lceil{\\frac{pDeviceRenderAreas_{y}+pDeviceRenderAreas_{height}}{maxFragmentDensityTexelSize_{height}}}\\right\\rceil\\) for each element of pDeviceRenderAreas" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)+!(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkRenderingInfoKHR-imageView-06117", + "text": " If the imageView member of a VkRenderingFragmentShadingRateAttachmentInfoKHR structure included in the pNext chain is not VK_NULL_HANDLE, imageView must have a width greater than or equal to \\(\\left\\lceil{\\frac{renderArea_{x}+renderArea_{width}}{shadingRateAttachmentTexelSize_{width}}}\\right\\rceil\\)" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-imageView-06118", + "text": " If the imageView member of a VkRenderingFragmentShadingRateAttachmentInfoKHR structure included in the pNext chain is not VK_NULL_HANDLE, imageView must have a height greater than or equal to \\(\\left\\lceil{\\frac{renderArea_{y}+renderArea_{height}}{shadingRateAttachmentTexelSize_{height}}}\\right\\rceil\\)" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkRenderingInfoKHR-pNext-06119", + "text": " If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0 and the imageView member of a VkRenderingFragmentShadingRateAttachmentInfoKHR structure included in the pNext chain is not VK_NULL_HANDLE, imageView must have a width greater than or equal to \\(\\left\\lceil{\\frac{renderArea_{x}+renderArea_{width}}{shadingRateAttachmentTexelSize_{width}}}\\right\\rceil\\)" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pNext-06120", + "text": " If the pNext chain contains a VkDeviceGroupRenderPassBeginInfo structure, its deviceRenderAreaCount member is not 0, and the imageView member of a VkRenderingFragmentShadingRateAttachmentInfoKHR structure included in the pNext chain is not VK_NULL_HANDLE, imageView must have a width greater than or equal to \\(\\left\\lceil{\\frac{pDeviceRenderAreas_{x}+pDeviceRenderAreas_{width}}{shadingRateAttachmentTexelSize_{width}}}\\right\\rceil\\) for each element of pDeviceRenderAreas" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pNext-06121", + "text": " If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0 and the imageView member of a VkRenderingFragmentShadingRateAttachmentInfoKHR structure included in the pNext chain is not VK_NULL_HANDLE, imageView must have a height greater than or equal to \\(\\left\\lceil{\\frac{renderArea_{y}+renderArea_{height}}{shadingRateAttachmentTexelSize_{height}}}\\right\\rceil\\)" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-pNext-06122", + "text": " If the pNext chain contains a VkDeviceGroupRenderPassBeginInfo structure, its deviceRenderAreaCount member is not 0, and the imageView member of a VkRenderingFragmentShadingRateAttachmentInfoKHR structure included in the pNext chain is not VK_NULL_HANDLE, imageView must have a height greater than or equal to \\(\\left\\lceil{\\frac{pDeviceRenderAreas_{y}+pDeviceRenderAreas_{height}}{shadingRateAttachmentTexelSize_{height}}}\\right\\rceil\\) for each element of pDeviceRenderAreas" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-VkRenderingInfoKHR-imageView-06123", + "text": " If the imageView member of a VkRenderingFragmentShadingRateAttachmentInfoKHR structure included in the pNext chain is not VK_NULL_HANDLE, and viewMask is 0, imageView must have a layerCount that is either equal to 1 or greater than or equal to layerCount" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-imageView-06124", + "text": " If the imageView member of a VkRenderingFragmentShadingRateAttachmentInfoKHR structure included in the pNext chain is not VK_NULL_HANDLE, and viewMask is not 0, imageView must have a layerCount that either equal to 1 or greater than or equal to the index of the most significant bit in viewMask" + }, + { + "vuid": "VUID-VkRenderingInfoKHR-imageView-06125", + "text": " If the imageView member of a VkRenderingFragmentShadingRateAttachmentInfoKHR structure included in the pNext chain is not VK_NULL_HANDLE, it must not be equal to the imageView or resolveImageView member of pDepthAttachment, pStencilAttachment, or any element of pColorAttachments" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkRenderingInfoKHR-imageView-06126", + "text": " If the imageView member of a VkRenderingFragmentShadingRateAttachmentInfoKHR structure included in the pNext chain is not VK_NULL_HANDLE, it must not be equal to the imageView member of a VkRenderingFragmentDensityMapAttachmentInfoEXT structure included in the pNext chain" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkRenderingInfoKHR-viewMask-06128", + "text": " The index of the most significant bit in viewMask must be less than maxMultiviewViewCount" + } + ] + }, + "VkRenderingAttachmentInfoKHR": { + "(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-VkRenderingAttachmentInfoKHR-imageView-06129", + "text": " If imageView is not VK_NULL_HANDLE and has a non-integer color format, resolveMode must be VK_RESOLVE_MODE_NONE or VK_RESOLVE_MODE_AVERAGE_BIT" + }, + { + "vuid": "VUID-VkRenderingAttachmentInfoKHR-imageView-06130", + "text": " If imageView is not VK_NULL_HANDLE and has an integer color format, resolveMode must be VK_RESOLVE_MODE_NONE or VK_RESOLVE_MODE_SAMPLE_ZERO_BIT" + }, + { + "vuid": "VUID-VkRenderingAttachmentInfoKHR-imageView-06132", + "text": " If imageView is not VK_NULL_HANDLE and resolveMode is not VK_RESOLVE_MODE_NONE, imageView must not have a sample count of VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-VkRenderingAttachmentInfoKHR-imageView-06133", + "text": " If imageView is not VK_NULL_HANDLE and resolveMode is not VK_RESOLVE_MODE_NONE, resolveImageView must have a sample count of VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-VkRenderingAttachmentInfoKHR-imageView-06134", + "text": " If imageView is not VK_NULL_HANDLE and resolveMode is not VK_RESOLVE_MODE_NONE, imageView and resolveImageView must have the same VkFormat" + }, + { + "vuid": "VUID-VkRenderingAttachmentInfoKHR-imageView-06135", + "text": " If imageView is not VK_NULL_HANDLE, layout must not be VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, or VK_IMAGE_LAYOUT_PREINITIALIZED" + }, + { + "vuid": "VUID-VkRenderingAttachmentInfoKHR-imageView-06136", + "text": " If imageView is not VK_NULL_HANDLE and resolveMode is not VK_RESOLVE_MODE_NONE, resolveImageLayout must not be VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, or VK_IMAGE_LAYOUT_PREINITIALIZED" + } + ], + "(VK_KHR_dynamic_rendering)+!(VK_KHR_depth_stencil_resolve,VK_VERSION_1_2)": [ + { + "vuid": "VUID-VkRenderingAttachmentInfoKHR-imageView-06131", + "text": " If imageView is not VK_NULL_HANDLE and has a depth or stencil format, resolveMode must be VK_RESOLVE_MODE_NONE" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_KHR_separate_depth_stencil_layouts,VK_VERSION_1_2)": [ + { + "vuid": "VUID-VkRenderingAttachmentInfoKHR-imageView-06137", + "text": " If imageView is not VK_NULL_HANDLE and resolveMode is not VK_RESOLVE_MODE_NONE, resolveImageLayout must not be VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkRenderingAttachmentInfoKHR-imageView-06138", + "text": " If imageView is not VK_NULL_HANDLE, layout must not be VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV" + }, + { + "vuid": "VUID-VkRenderingAttachmentInfoKHR-imageView-06139", + "text": " If imageView is not VK_NULL_HANDLE and resolveMode is not VK_RESOLVE_MODE_NONE, resolveImageLayout must not be VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkRenderingAttachmentInfoKHR-imageView-06140", + "text": " If imageView is not VK_NULL_HANDLE, layout must not be VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT" + }, + { + "vuid": "VUID-VkRenderingAttachmentInfoKHR-imageView-06141", + "text": " If imageView is not VK_NULL_HANDLE and resolveMode is not VK_RESOLVE_MODE_NONE, resolveImageLayout must not be VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-VkRenderingAttachmentInfoKHR-imageView-06142", + "text": " If imageView is not VK_NULL_HANDLE and resolveMode is not VK_RESOLVE_MODE_NONE, resolveImageLayout must not be VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-VkRenderingAttachmentInfoKHR-imageView-06143", + "text": " If imageView is not VK_NULL_HANDLE, layout must not be VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR" + }, + { + "vuid": "VUID-VkRenderingAttachmentInfoKHR-imageView-06144", + "text": " If imageView is not VK_NULL_HANDLE and resolveMode is not VK_RESOLVE_MODE_NONE, resolveImageLayout must not be VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_KHR_swapchain)": [ + { + "vuid": "VUID-VkRenderingAttachmentInfoKHR-imageView-06145", + "text": " If imageView is not VK_NULL_HANDLE, layout must not be VK_IMAGE_LAYOUT_PRESENT_SRC_KHR" + }, + { + "vuid": "VUID-VkRenderingAttachmentInfoKHR-imageView-06146", + "text": " If imageView is not VK_NULL_HANDLE and resolveMode is not VK_RESOLVE_MODE_NONE, resolveImageLayout must not be VK_IMAGE_LAYOUT_PRESENT_SRC_KHR" + } + ] + }, + "VkRenderingFragmentShadingRateAttachmentInfoKHR": { + "(VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-VkRenderingFragmentShadingRateAttachmentInfoKHR-imageView-06147", + "text": " If imageView is not VK_NULL_HANDLE, layout must be VK_IMAGE_LAYOUT_GENERAL or VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR" + }, + { + "vuid": "VUID-VkRenderingFragmentShadingRateAttachmentInfoKHR-imageView-06148", + "text": " If imageView is not VK_NULL_HANDLE, it must have been created with VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" + }, + { + "vuid": "VUID-VkRenderingFragmentShadingRateAttachmentInfoKHR-imageView-06149", + "text": " If imageView is not VK_NULL_HANDLE, shadingRateAttachmentTexelSize.width must be a power of two value" + }, + { + "vuid": "VUID-VkRenderingFragmentShadingRateAttachmentInfoKHR-imageView-06150", + "text": " If imageView is not VK_NULL_HANDLE, shadingRateAttachmentTexelSize.width must be less than or equal to maxFragmentShadingRateAttachmentTexelSize.width" + }, + { + "vuid": "VUID-VkRenderingFragmentShadingRateAttachmentInfoKHR-imageView-06151", + "text": " If imageView is not VK_NULL_HANDLE, shadingRateAttachmentTexelSize.width must be greater than or equal to minFragmentShadingRateAttachmentTexelSize.width" + }, + { + "vuid": "VUID-VkRenderingFragmentShadingRateAttachmentInfoKHR-imageView-06152", + "text": " If imageView is not VK_NULL_HANDLE, shadingRateAttachmentTexelSize.height must be a power of two value" + }, + { + "vuid": "VUID-VkRenderingFragmentShadingRateAttachmentInfoKHR-imageView-06153", + "text": " If imageView is not VK_NULL_HANDLE, shadingRateAttachmentTexelSize.height must be less than or equal to maxFragmentShadingRateAttachmentTexelSize.height" + }, + { + "vuid": "VUID-VkRenderingFragmentShadingRateAttachmentInfoKHR-imageView-06154", + "text": " If imageView is not VK_NULL_HANDLE, shadingRateAttachmentTexelSize.height must be greater than or equal to minFragmentShadingRateAttachmentTexelSize.height" + }, + { + "vuid": "VUID-VkRenderingFragmentShadingRateAttachmentInfoKHR-imageView-06155", + "text": " If imageView is not VK_NULL_HANDLE, the quotient of shadingRateAttachmentTexelSize.width and shadingRateAttachmentTexelSize.height must be less than or equal to maxFragmentShadingRateAttachmentTexelSizeAspectRatio" + }, + { + "vuid": "VUID-VkRenderingFragmentShadingRateAttachmentInfoKHR-imageView-06156", + "text": " If imageView is not VK_NULL_HANDLE, the quotient of shadingRateAttachmentTexelSize.height and shadingRateAttachmentTexelSize.width must be less than or equal to maxFragmentShadingRateAttachmentTexelSizeAspectRatio" + } + ] + }, + "VkRenderingFragmentDensityMapAttachmentInfoEXT": { + "(VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkRenderingFragmentDensityMapAttachmentInfoEXT-imageView-06157", + "text": " If imageView is not VK_NULL_HANDLE, layout must be VK_IMAGE_LAYOUT_GENERAL or VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT" + }, + { + "vuid": "VUID-VkRenderingFragmentDensityMapAttachmentInfoEXT-imageView-06158", + "text": " If imageView is not VK_NULL_HANDLE, it must have been created with VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT" + }, + { + "vuid": "VUID-VkRenderingFragmentDensityMapAttachmentInfoEXT-imageView-06159", + "text": " If imageView is not VK_NULL_HANDLE, it must not have been created with VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)+!(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkRenderingFragmentDensityMapAttachmentInfoEXT-imageView-06160", + "text": " If imageView is not VK_NULL_HANDLE, it must have a layerCount equal to 1" + } + ] + }, + "vkCmdEndRenderingKHR": { + "(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdEndRenderingKHR-None-06161", + "text": " The current render pass instance must have been begun with vkCmdBeginRenderingKHR" + }, + { + "vuid": "VUID-vkCmdEndRenderingKHR-commandBuffer-06162", + "text": " The current render pass instance must have been begun in commandBuffer" + } + ] + }, + "vkCreateRenderPass": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateRenderPass-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + }, + { + "vuid": "VUID-vkCreateRenderPass-device-05089", + "text": " The number of subpasses currently allocated from device across all slink:VkRenderPass objects plus pname:pCreateInfo->subpassCount must be less than or equal to the total number of subpasses requested via VkDeviceObjectReservationCreateInfo::pname:subpassDescriptionRequestCount specified when device was created" + }, + { + "vuid": "VUID-vkCreateRenderPass-device-05089", + "text": " The number of attachments currently allocated from device across all slink:VkRenderPass objects plus pname:pCreateInfo->attachmentCount must be less than or equal to the total number of attachments requested via VkDeviceObjectReservationCreateInfo::pname:attachmentDescriptionRequestCount specified when device was created" + } + ], + "core": [ + { + "vuid": "VUID-vkCreateRenderPass-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateRenderPass-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkRenderPassCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateRenderPass-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateRenderPass-pRenderPass-parameter", + "text": " pRenderPass must be a valid pointer to a VkRenderPass handle" + } + ] + }, + "VkRenderPassCreateInfo": { + "core": [ + { + "vuid": "VUID-VkRenderPassCreateInfo-attachment-00834", + "text": " If the attachment member of any element of pInputAttachments, pColorAttachments, pResolveAttachments or pDepthStencilAttachment, or any element of pPreserveAttachments in any element of pSubpasses is not VK_ATTACHMENT_UNUSED, then it must be less than attachmentCount" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pAttachments-00836", + "text": " For any member of pAttachments with a loadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pAttachments-02511", + "text": " For any member of pAttachments with a stencilLoadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pDependencies-00837", + "text": " For any element of pDependencies, if the srcSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the srcStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pDependencies-00838", + "text": " For any element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the destination subpass" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-srcSubpass-02517", + "text": " The srcSubpass member of each element of pDependencies must be less than subpassCount" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-dstSubpass-02518", + "text": " The dstSubpass member of each element of pDependencies must be less than subpassCount" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkRenderPassInputAttachmentAspectCreateInfo or VkRenderPassMultiviewCreateInfo" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pAttachments-parameter", + "text": " If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkAttachmentDescription structures" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pSubpasses-parameter", + "text": " pSubpasses must be a valid pointer to an array of subpassCount valid VkSubpassDescription structures" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pDependencies-parameter", + "text": " If dependencyCount is not 0, pDependencies must be a valid pointer to an array of dependencyCount valid VkSubpassDependency structures" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-subpassCount-arraylength", + "text": " subpassCount must be greater than 0" + } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkRenderPassCreateInfo-fragmentDensityMapAttachment-06471", + "text": " If the pNext chain includes a VkRenderPassFragmentDensityMapCreateInfoEXT structure and the fragmentDensityMapAttachment member is not VK_ATTACHMENT_UNUSED, then attachment must be less than attachmentCount" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkRenderPassCreateInfo-pAttachments-01566", + "text": " For any member of pAttachments with a loadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pAttachments-01567", + "text": " For any member of pAttachments with a stencilLoadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-01926", + "text": " If the pNext chain includes a VkRenderPassInputAttachmentAspectCreateInfo structure, the subpass member of each element of its pAspectReferences member must be less than subpassCount" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-01927", + "text": " If the pNext chain includes a VkRenderPassInputAttachmentAspectCreateInfo structure, the inputAttachmentIndex member of each element of its pAspectReferences member must be less than the value of inputAttachmentCount in the element of pSubpasses identified by its subpass member" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-01963", + "text": " If the pNext chain includes a VkRenderPassInputAttachmentAspectCreateInfo structure, for any element of the pInputAttachments member of any element of pSubpasses where the attachment member is not VK_ATTACHMENT_UNUSED, the aspectMask member of the corresponding element of VkRenderPassInputAttachmentAspectCreateInfo::pAspectReferences must only include aspects that are present in images of the format specified by the element of pAttachments at attachment" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-01928", + "text": " If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, and its subpassCount member is not zero, that member must be equal to the value of subpassCount" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-01929", + "text": " If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, if its dependencyCount member is not zero, it must be equal to dependencyCount" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-01930", + "text": " If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, for each non-zero element of pViewOffsets, the srcSubpass and dstSubpass members of pDependencies at the same index must not be equal" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-02512", + "text": " If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, for any element of pDependencies with a dependencyFlags member that does not include VK_DEPENDENCY_VIEW_LOCAL_BIT, the corresponding element of the pViewOffsets member of that VkRenderPassMultiviewCreateInfo instance must be 0" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-02513", + "text": " If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, elements of its pViewMasks member must either all be 0, or all not be 0" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-02514", + "text": " If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, and each element of its pViewMasks member is 0, the dependencyFlags member of each element of pDependencies must not include VK_DEPENDENCY_VIEW_LOCAL_BIT" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pNext-02515", + "text": " If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, and each element of its pViewMasks member is 0, its correlationMaskCount member must be 0" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkRenderPassCreateInfo-subpassCount-05050", + "text": " subpassCount must be less than or equal to maxRenderPassSubpasses" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-dependencyCount-05051", + "text": " dependencyCount must be less than or equal to maxRenderPassDependencies" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-attachmentCount-05052", + "text": " attachmentCount must be less than or equal to maxFramebufferAttachments" + } + ] + }, + "VkRenderPassMultiviewCreateInfo": { + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkRenderPassMultiviewCreateInfo-pCorrelationMasks-00841", + "text": " Each view index must not be set in more than one element of pCorrelationMasks" + }, + { + "vuid": "VUID-VkRenderPassMultiviewCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO" + }, + { + "vuid": "VUID-VkRenderPassMultiviewCreateInfo-pViewMasks-parameter", + "text": " If subpassCount is not 0, pViewMasks must be a valid pointer to an array of subpassCount uint32_t values" + }, + { + "vuid": "VUID-VkRenderPassMultiviewCreateInfo-pViewOffsets-parameter", + "text": " If dependencyCount is not 0, pViewOffsets must be a valid pointer to an array of dependencyCount int32_t values" + }, + { + "vuid": "VUID-VkRenderPassMultiviewCreateInfo-pCorrelationMasks-parameter", + "text": " If correlationMaskCount is not 0, pCorrelationMasks must be a valid pointer to an array of correlationMaskCount uint32_t values" + } + ] + }, + "VkMultiviewPerViewAttributesInfoNVX": { + "(VK_NVX_multiview_per_view_attributes)+(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-VkMultiviewPerViewAttributesInfoNVX-perViewAttributesPositionXOnly-06163", + "text": " If perViewAttributesPositionXOnly is VK_TRUE then perViewAttributes must also be VK_TRUE" + } + ] + }, + "VkRenderPassFragmentDensityMapCreateInfoEXT": { + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02548", + "text": " If fragmentDensityMapAttachment is not VK_ATTACHMENT_UNUSED, fragmentDensityMapAttachment must not be an element of VkSubpassDescription::pInputAttachments, VkSubpassDescription::pColorAttachments, VkSubpassDescription::pResolveAttachments, VkSubpassDescription::pDepthStencilAttachment, or VkSubpassDescription::pPreserveAttachments for any subpass" + }, + { + "vuid": "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02549", + "text": " If fragmentDensityMapAttachment is not VK_ATTACHMENT_UNUSED, layout must be equal to VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT, or VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02550", + "text": " If fragmentDensityMapAttachment is not VK_ATTACHMENT_UNUSED, fragmentDensityMapAttachment must reference an attachment with a loadOp equal to VK_ATTACHMENT_LOAD_OP_LOAD or VK_ATTACHMENT_LOAD_OP_DONT_CARE" + }, + { + "vuid": "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02551", + "text": " If fragmentDensityMapAttachment is not VK_ATTACHMENT_UNUSED, fragmentDensityMapAttachment must reference an attachment with a storeOp equal to VK_ATTACHMENT_STORE_OP_DONT_CARE" + } + ] + }, + "VkAttachmentDescription": { + "core": [ + { + "vuid": "VUID-VkAttachmentDescription-finalLayout-00843", + "text": " finalLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED" + }, + { + "vuid": "VUID-VkAttachmentDescription-format-03280", + "text": " If format is a color format, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription-format-03281", + "text": " If format is a depth/stencil format, initialLayout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription-format-03282", + "text": " If format is a color format, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription-format-03283", + "text": " If format is a depth/stencil format, finalLayout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription-flags-parameter", + "text": " flags must be a valid combination of VkAttachmentDescriptionFlagBits values" + }, + { + "vuid": "VUID-VkAttachmentDescription-format-parameter", + "text": " format must be a valid VkFormat value" + }, + { + "vuid": "VUID-VkAttachmentDescription-samples-parameter", + "text": " samples must be a valid VkSampleCountFlagBits value" + }, + { + "vuid": "VUID-VkAttachmentDescription-loadOp-parameter", + "text": " loadOp must be a valid VkAttachmentLoadOp value" + }, + { + "vuid": "VUID-VkAttachmentDescription-storeOp-parameter", + "text": " storeOp must be a valid VkAttachmentStoreOp value" + }, + { + "vuid": "VUID-VkAttachmentDescription-stencilLoadOp-parameter", + "text": " stencilLoadOp must be a valid VkAttachmentLoadOp value" + }, + { + "vuid": "VUID-VkAttachmentDescription-stencilStoreOp-parameter", + "text": " stencilStoreOp must be a valid VkAttachmentStoreOp value" + }, + { + "vuid": "VUID-VkAttachmentDescription-initialLayout-parameter", + "text": " initialLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-VkAttachmentDescription-finalLayout-parameter", + "text": " finalLayout must be a valid VkImageLayout value" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkAttachmentDescription-format-06487", + "text": " If format is a color format, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription-format-06488", + "text": " If format is a color format, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL" + } + ], + "(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-VkAttachmentDescription-separateDepthStencilLayouts-03284", + "text": " If the separateDepthStencilLayouts feature is not enabled, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription-separateDepthStencilLayouts-03285", + "text": " If the separateDepthStencilLayouts feature is not enabled, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription-format-03286", + "text": " If format is a color format, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription-format-03287", + "text": " If format is a color format, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription-format-03288", + "text": " If format is a depth/stencil format which includes both depth and stencil aspects, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription-format-03289", + "text": " If format is a depth/stencil format which includes both depth and stencil aspects, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription-format-03290", + "text": " If format is a depth/stencil format which includes only the depth aspect, initialLayout must not be VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription-format-03291", + "text": " If format is a depth/stencil format which includes only the depth aspect, finalLayout must not be VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription-format-03292", + "text": " If format is a depth/stencil format which includes only the stencil aspect, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription-format-03293", + "text": " If format is a depth/stencil format which includes only the stencil aspect, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL" + } + ] + }, + "VkRenderPassInputAttachmentAspectCreateInfo": { + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkRenderPassInputAttachmentAspectCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO" + }, + { + "vuid": "VUID-VkRenderPassInputAttachmentAspectCreateInfo-pAspectReferences-parameter", + "text": " pAspectReferences must be a valid pointer to an array of aspectReferenceCount valid VkInputAttachmentAspectReference structures" + }, + { + "vuid": "VUID-VkRenderPassInputAttachmentAspectCreateInfo-aspectReferenceCount-arraylength", + "text": " aspectReferenceCount must be greater than 0" + } + ] + }, + "VkInputAttachmentAspectReference": { + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkInputAttachmentAspectReference-aspectMask-01964", + "text": " aspectMask must not include VK_IMAGE_ASPECT_METADATA_BIT" + }, + { + "vuid": "VUID-VkInputAttachmentAspectReference-aspectMask-parameter", + "text": " aspectMask must be a valid combination of VkImageAspectFlagBits values" + }, + { + "vuid": "VUID-VkInputAttachmentAspectReference-aspectMask-requiredbitmask", + "text": " aspectMask must not be 0" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance2)+(VK_EXT_image_drm_format_modifier)": [ + { + "vuid": "VUID-VkInputAttachmentAspectReference-aspectMask-02250", + "text": " aspectMask must not include VK_IMAGE_ASPECT_MEMORY_PLANE{ibit}BIT_EXT for any index i" + } + ] + }, + "VkSubpassDescription": { + "!(VK_HUAWEI_subpass_shading)": [ + { + "vuid": "VUID-VkSubpassDescription-pipelineBindPoint-00844", + "text": " pipelineBindPoint must be VK_PIPELINE_BIND_POINT_GRAPHICS" + } + ], + "(VK_HUAWEI_subpass_shading)": [ + { + "vuid": "VUID-VkSubpassDescription-pipelineBindPoint-04952", + "text": " pipelineBindPoint must be VK_PIPELINE_BIND_POINT_GRAPHICS or VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI" + } + ], + "core": [ + { + "vuid": "VUID-VkSubpassDescription-colorAttachmentCount-00845", + "text": " colorAttachmentCount must be less than or equal to VkPhysicalDeviceLimits::maxColorAttachments" + }, + { + "vuid": "VUID-VkSubpassDescription-loadOp-00846", + "text": " If the first use of an attachment in this render pass is as an input attachment, and the attachment is not also used as a color or depth/stencil attachment in the same subpass, then loadOp must not be VK_ATTACHMENT_LOAD_OP_CLEAR" + }, + { + "vuid": "VUID-VkSubpassDescription-pResolveAttachments-00847", + "text": " If pResolveAttachments is not NULL, for each resolve attachment that is not VK_ATTACHMENT_UNUSED, the corresponding color attachment must not be VK_ATTACHMENT_UNUSED" + }, + { + "vuid": "VUID-VkSubpassDescription-pResolveAttachments-00848", + "text": " If pResolveAttachments is not NULL, for each resolve attachment that is not VK_ATTACHMENT_UNUSED, the corresponding color attachment must not have a sample count of VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-VkSubpassDescription-pResolveAttachments-00849", + "text": " If pResolveAttachments is not NULL, each resolve attachment that is not VK_ATTACHMENT_UNUSED must have a sample count of VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-VkSubpassDescription-pResolveAttachments-00850", + "text": " If pResolveAttachments is not NULL, each resolve attachment that is not VK_ATTACHMENT_UNUSED must have the same VkFormat as its corresponding color attachment" + }, + { + "vuid": "VUID-VkSubpassDescription-pColorAttachments-01417", + "text": " All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have the same sample count" + }, + { + "vuid": "VUID-VkSubpassDescription-pInputAttachments-02647", + "text": " All attachments in pInputAttachments that are not VK_ATTACHMENT_UNUSED must have image formats whose potential format features contain at least VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT or VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkSubpassDescription-pColorAttachments-02648", + "text": " All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have image formats whose potential format features contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkSubpassDescription-pResolveAttachments-02649", + "text": " All attachments in pResolveAttachments that are not VK_ATTACHMENT_UNUSED must have image formats whose potential format features contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkSubpassDescription-pDepthStencilAttachment-02650", + "text": " If pDepthStencilAttachment is not NULL and the attachment is not VK_ATTACHMENT_UNUSED then it must have an image format whose potential format features contain VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkSubpassDescription-pDepthStencilAttachment-01418", + "text": " If neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, and if pDepthStencilAttachment is not VK_ATTACHMENT_UNUSED and any attachments in pColorAttachments are not VK_ATTACHMENT_UNUSED, they must have the same sample count" + }, + { + "vuid": "VUID-VkSubpassDescription-attachment-00853", + "text": " Each element of pPreserveAttachments must not be VK_ATTACHMENT_UNUSED" + }, + { + "vuid": "VUID-VkSubpassDescription-pPreserveAttachments-00854", + "text": " Each element of pPreserveAttachments must not also be an element of any other member of the subpass description" + }, + { + "vuid": "VUID-VkSubpassDescription-layout-02519", + "text": " If any attachment is used by more than one VkAttachmentReference member, then each use must use the same layout" + }, + { + "vuid": "VUID-VkSubpassDescription-None-04437", + "text": " Each attachment must follow the image layout requirements specified for its attachment type" + }, + { + "vuid": "VUID-VkSubpassDescription-pDepthStencilAttachment-04438", + "text": " pDepthStencilAttachment and pColorAttachments must not contain references to the same attachment" + }, + { + "vuid": "VUID-VkSubpassDescription-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkSubpassDescription-pipelineBindPoint-parameter", + "text": " pipelineBindPoint must be a valid VkPipelineBindPoint value" + }, + { + "vuid": "VUID-VkSubpassDescription-pInputAttachments-parameter", + "text": " If inputAttachmentCount is not 0, pInputAttachments must be a valid pointer to an array of inputAttachmentCount valid VkAttachmentReference structures" + }, + { + "vuid": "VUID-VkSubpassDescription-pColorAttachments-parameter", + "text": " If colorAttachmentCount is not 0, pColorAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference structures" + }, + { + "vuid": "VUID-VkSubpassDescription-pResolveAttachments-parameter", + "text": " If colorAttachmentCount is not 0, and pResolveAttachments is not NULL, pResolveAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference structures" + }, + { + "vuid": "VUID-VkSubpassDescription-pDepthStencilAttachment-parameter", + "text": " If pDepthStencilAttachment is not NULL, pDepthStencilAttachment must be a valid pointer to a valid VkAttachmentReference structure" + }, + { + "vuid": "VUID-VkSubpassDescription-pPreserveAttachments-parameter", + "text": " If preserveAttachmentCount is not 0, pPreserveAttachments must be a valid pointer to an array of preserveAttachmentCount uint32_t values" + } + ], + "(VK_AMD_mixed_attachment_samples)": [ + { + "vuid": "VUID-VkSubpassDescription-pColorAttachments-01506", + "text": " If the VK_AMD_mixed_attachment_samples extension is enabled, and all attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have a sample count that is smaller than or equal to the sample count of pDepthStencilAttachment if it is not VK_ATTACHMENT_UNUSED" + } + ], + "(VK_NVX_multiview_per_view_attributes)": [ + { + "vuid": "VUID-VkSubpassDescription-flags-00856", + "text": " If flags includes VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX, it must also include VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX" + } + ], + "(VK_QCOM_render_pass_shader_resolve)": [ + { + "vuid": "VUID-VkSubpassDescription-flags-03341", + "text": " If flags includes VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM, and if pResolveAttachments is not NULL, then each resolve attachment must be VK_ATTACHMENT_UNUSED" + }, + { + "vuid": "VUID-VkSubpassDescription-flags-03343", + "text": " If flags includes VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM, then the subpass must be the last subpass in a subpass dependency chain" + } + ], + "(VK_QCOM_render_pass_transform)": [ + { + "vuid": "VUID-VkSubpassDescription-pInputAttachments-02868", + "text": " If the render pass is created with VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM each of the elements of pInputAttachments must be VK_ATTACHMENT_UNUSED" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkSubpassDescription-inputAttachmentCount-05053", + "text": " inputAttachmentCount must be less than or equal to maxSubpassInputAttachments" + }, + { + "vuid": "VUID-VkSubpassDescription-preserveAttachmentCount-05054", + "text": " preserveAttachmentCount must be less than or equal to maxSubpassPreserveAttachments" + } + ] + }, + "VkAttachmentReference": { + "core": [ + { + "vuid": "VUID-VkAttachmentReference-layout-00857", + "text": " If attachment is not VK_ATTACHMENT_UNUSED, layout must not be VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_PREINITIALIZED, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentReference-layout-parameter", + "text": " layout must be a valid VkImageLayout value" + } + ] + }, + "VkSubpassDependency": { + "core": [ + { + "vuid": "VUID-VkSubpassDependency-srcStageMask-04090", + "text": " If the geometry shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-VkSubpassDependency-srcStageMask-04091", + "text": " If the tessellation shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-VkSubpassDependency-dstStageMask-04090", + "text": " If the geometry shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-VkSubpassDependency-dstStageMask-04091", + "text": " If the tessellation shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-VkSubpassDependency-srcSubpass-00864", + "text": " srcSubpass must be less than or equal to dstSubpass, unless one of them is VK_SUBPASS_EXTERNAL, to avoid cyclic dependencies and ensure a valid execution order" + }, + { + "vuid": "VUID-VkSubpassDependency-srcSubpass-00865", + "text": " srcSubpass and dstSubpass must not both be equal to VK_SUBPASS_EXTERNAL" + }, + { + "vuid": "VUID-VkSubpassDependency-srcSubpass-00867", + "text": " If srcSubpass is equal to dstSubpass and not all of the stages in srcStageMask and dstStageMask are framebuffer-space stages, the logically latest pipeline stage in srcStageMask must be logically earlier than or equal to the logically earliest pipeline stage in dstStageMask" + }, + { + "vuid": "VUID-VkSubpassDependency-srcAccessMask-00868", + "text": " Any access flag included in srcAccessMask must be supported by one of the pipeline stages in srcStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-VkSubpassDependency-dstAccessMask-00869", + "text": " Any access flag included in dstAccessMask must be supported by one of the pipeline stages in dstStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-VkSubpassDependency-srcSubpass-02243", + "text": " If srcSubpass equals dstSubpass, and srcStageMask and dstStageMask both include a framebuffer-space stage, then dependencyFlags must include VK_DEPENDENCY_BY_REGION_BIT" + }, + { + "vuid": "VUID-VkSubpassDependency-srcStageMask-parameter", + "text": " srcStageMask must be a valid combination of VkPipelineStageFlagBits values" + }, + { + "vuid": "VUID-VkSubpassDependency-dstStageMask-parameter", + "text": " dstStageMask must be a valid combination of VkPipelineStageFlagBits values" + }, + { + "vuid": "VUID-VkSubpassDependency-srcAccessMask-parameter", + "text": " srcAccessMask must be a valid combination of VkAccessFlagBits values" + }, + { + "vuid": "VUID-VkSubpassDependency-dstAccessMask-parameter", + "text": " dstAccessMask must be a valid combination of VkAccessFlagBits values" + }, + { + "vuid": "VUID-VkSubpassDependency-dependencyFlags-parameter", + "text": " dependencyFlags must be a valid combination of VkDependencyFlagBits values" + } + ], + "(VK_EXT_conditional_rendering)": [ + { + "vuid": "VUID-VkSubpassDependency-srcStageMask-04092", + "text": " If the conditional rendering feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT" + }, + { + "vuid": "VUID-VkSubpassDependency-dstStageMask-04092", + "text": " If the conditional rendering feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT" + } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkSubpassDependency-srcStageMask-04093", + "text": " If the fragment density map feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + }, + { + "vuid": "VUID-VkSubpassDependency-dstStageMask-04093", + "text": " If the fragment density map feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + } + ], + "(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-VkSubpassDependency-srcStageMask-04094", + "text": " If the transform feedback feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT" + }, + { + "vuid": "VUID-VkSubpassDependency-dstStageMask-04094", + "text": " If the transform feedback feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT" + } + ], + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-VkSubpassDependency-srcStageMask-04095", + "text": " If the mesh shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV" + }, + { + "vuid": "VUID-VkSubpassDependency-srcStageMask-04096", + "text": " If the task shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV" + }, + { + "vuid": "VUID-VkSubpassDependency-dstStageMask-04095", + "text": " If the mesh shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV" + }, + { + "vuid": "VUID-VkSubpassDependency-dstStageMask-04096", + "text": " If the task shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV" + } + ], + "(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkSubpassDependency-srcStageMask-04097", + "text": " If the shading rate image feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV" + }, + { + "vuid": "VUID-VkSubpassDependency-dstStageMask-04097", + "text": " If the shading rate image feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV" + } + ], + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-VkSubpassDependency-srcStageMask-03937", + "text": " If the synchronization2 feature is not enabled, pname:srcStageMask must not be 0" + }, + { + "vuid": "VUID-VkSubpassDependency-dstStageMask-03937", + "text": " If the synchronization2 feature is not enabled, pname:dstStageMask must not be 0" + } + ], + "!(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-VkSubpassDependency-srcStageMask-04996", + "text": " pname:srcStageMask must not be 0" + }, + { + "vuid": "VUID-VkSubpassDependency-dstStageMask-04996", + "text": " pname:dstStageMask must not be 0" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkSubpassDependency-dependencyFlags-02520", + "text": " If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, srcSubpass must not be equal to VK_SUBPASS_EXTERNAL" + }, + { + "vuid": "VUID-VkSubpassDependency-dependencyFlags-02521", + "text": " If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, dstSubpass must not be equal to VK_SUBPASS_EXTERNAL" + }, + { + "vuid": "VUID-VkSubpassDependency-srcSubpass-00872", + "text": " If srcSubpass equals dstSubpass and that subpass has more than one bit set in the view mask, then dependencyFlags must include VK_DEPENDENCY_VIEW_LOCAL_BIT" + } + ] + }, + "vkCreateRenderPass2": { + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateRenderPass2-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + }, + { + "vuid": "VUID-vkCreateRenderPass2-device-05089", + "text": " The number of subpasses currently allocated from device across all slink:VkRenderPass objects plus pname:pCreateInfo->subpassCount must be less than or equal to the total number of subpasses requested via VkDeviceObjectReservationCreateInfo::pname:subpassDescriptionRequestCount specified when device was created" + }, + { + "vuid": "VUID-vkCreateRenderPass2-device-05089", + "text": " The number of attachments currently allocated from device across all slink:VkRenderPass objects plus pname:pCreateInfo->attachmentCount must be less than or equal to the total number of attachments requested via VkDeviceObjectReservationCreateInfo::pname:attachmentDescriptionRequestCount specified when device was created" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)": [ + { + "vuid": "VUID-vkCreateRenderPass2-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateRenderPass2-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkRenderPassCreateInfo2 structure" + }, + { + "vuid": "VUID-vkCreateRenderPass2-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateRenderPass2-pRenderPass-parameter", + "text": " pRenderPass must be a valid pointer to a VkRenderPass handle" + } + ] + }, + "VkRenderPassCreateInfo2": { + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)": [ + { + "vuid": "VUID-VkRenderPassCreateInfo2-None-03049", + "text": " If any two subpasses operate on attachments with overlapping ranges of the same VkDeviceMemory object, and at least one subpass writes to that area of VkDeviceMemory, a subpass dependency must be included (either directly or via some intermediate subpasses) between them" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-attachment-03050", + "text": " If the attachment member of any element of pInputAttachments, pColorAttachments, pResolveAttachments or pDepthStencilAttachment, or the attachment indexed by any element of pPreserveAttachments in any given element of pSubpasses is bound to a range of a VkDeviceMemory object that overlaps with any other attachment in any subpass (including the same subpass), the VkAttachmentDescription2 structures describing them must include VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT in flags" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-attachment-03051", + "text": " If the attachment member of any element of pInputAttachments, pColorAttachments, pResolveAttachments or pDepthStencilAttachment, or any element of pPreserveAttachments in any given element of pSubpasses is not VK_ATTACHMENT_UNUSED, then it must be less than attachmentCount" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-pAttachments-02522", + "text": " For any member of pAttachments with a loadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-pAttachments-02523", + "text": " For any member of pAttachments with a stencilLoadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-pDependencies-03054", + "text": " For any element of pDependencies, if the srcSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the srcStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-pDependencies-03055", + "text": " For any element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the destination subpass" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-pCorrelatedViewMasks-03056", + "text": " The set of bits included in any element of pCorrelatedViewMasks must not overlap with the set of bits included in any other element of pCorrelatedViewMasks" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-viewMask-03057", + "text": " If the VkSubpassDescription2::viewMask member of all elements of pSubpasses is 0, correlatedViewMaskCount must be 0" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-viewMask-03058", + "text": " The VkSubpassDescription2::viewMask member of all elements of pSubpasses must either all be 0, or all not be 0" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-viewMask-03059", + "text": " If the VkSubpassDescription2::viewMask member of all elements of pSubpasses is 0, the dependencyFlags member of any element of pDependencies must not include VK_DEPENDENCY_VIEW_LOCAL_BIT" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-pDependencies-03060", + "text": " For any element of pDependencies where its srcSubpass member equals its dstSubpass member, if the viewMask member of the corresponding element of pSubpasses includes more than one bit, its dependencyFlags member must include VK_DEPENDENCY_VIEW_LOCAL_BIT" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-attachment-02525", + "text": " If the attachment member of any element of the pInputAttachments member of any element of pSubpasses is not VK_ATTACHMENT_UNUSED, the aspectMask member of that element of pInputAttachments must only include aspects that are present in images of the format specified by the element of pAttachments specified by attachment" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-srcSubpass-02526", + "text": " The srcSubpass member of each element of pDependencies must be less than subpassCount" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-dstSubpass-02527", + "text": " The dstSubpass member of each element of pDependencies must be less than subpassCount" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-pAttachments-parameter", + "text": " If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkAttachmentDescription2 structures" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-pSubpasses-parameter", + "text": " pSubpasses must be a valid pointer to an array of subpassCount valid VkSubpassDescription2 structures" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-pDependencies-parameter", + "text": " If dependencyCount is not 0, pDependencies must be a valid pointer to an array of dependencyCount valid VkSubpassDependency2 structures" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-pCorrelatedViewMasks-parameter", + "text": " If correlatedViewMaskCount is not 0, pCorrelatedViewMasks must be a valid pointer to an array of correlatedViewMaskCount uint32_t values" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-subpassCount-arraylength", + "text": " subpassCount must be greater than 0" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkRenderPassCreateInfo2-fragmentDensityMapAttachment-06472", + "text": " If the pNext chain includes a VkRenderPassFragmentDensityMapCreateInfoEXT structure and the fragmentDensityMapAttachment member is not VK_ATTACHMENT_UNUSED, then attachment must be less than attachmentCount" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_VERSION_1_2,VK_KHR_depth_stencil_resolve)": [ + { + "vuid": "VUID-VkRenderPassCreateInfo2-pSubpasses-06473", + "text": " If the pSubpasses pNext chain includes a VkSubpassDescriptionDepthStencilResolve structure and the pDepthStencilResolveAttachment member is not NULL and does not have the value VK_ATTACHMENT_UNUSED, then attachment must be less than attachmentCount" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-VkRenderPassCreateInfo2-pAttachments-04585", + "text": " If any element of pAttachments is used as a fragment shading rate attachment in any subpass, it must not be used as any other attachment in the render pass" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-pAttachments-04586", + "text": " If any element of pAttachments is used as a fragment shading rate attachment in any subpass, it must have an image format whose potential format features contain VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_KHR_fragment_shading_rate)+(VK_QCOM_render_pass_transform)": [ + { + "vuid": "VUID-VkRenderPassCreateInfo2-flags-04521", + "text": " If flags includes VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM, an element of pSubpasses includes an instance of VkFragmentShadingRateAttachmentInfoKHR in its pNext chain, and the pFragmentShadingRateAttachment member of that structure is not equal to NULL, the attachment member of pFragmentShadingRateAttachment must be VK_ATTACHMENT_UNUSED" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_QCOM_render_pass_shader_resolve)": [ + { + "vuid": "VUID-VkRenderPassCreateInfo2-rasterizationSamples-04905", + "text": " If the pipeline is being created with fragment shader state, and the VK_QCOM_render_pass_shader_resolve extension is enabled, and if subpass has any input attachments, and if the subpass description contains VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM, then the sample count of the input attachments must equal rasterizationSamples" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-sampleShadingEnable-04906", + "text": " If the pipeline is being created with fragment shader state, and the VK_QCOM_render_pass_shader_resolve extension is enabled, and if the subpass description contains VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM, then sampleShadingEnable must be false" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-flags-04907", + "text": " If flags includes VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM, and if pResolveAttachments is not NULL, then each resolve attachment must be VK_ATTACHMENT_UNUSED" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-flags-04908", + "text": " If flags includes VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM, and if pDepthStencilResolveAttachment is not NULL, then the depth/stencil resolve attachment must be VK_ATTACHMENT_UNUSED" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-flags-04909", + "text": " If flags includes VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM, then the subpass must be the last subpass in a subpass dependency chain" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkRenderPassCreateInfo2-subpassCount-05055", + "text": " subpassCount must be less than or equal to maxRenderPassSubpasses" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-dependencyCount-05056", + "text": " dependencyCount must be less than or equal to maxRenderPassDependencies" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-attachmentCount-05057", + "text": " attachmentCount must be less than or equal to maxFramebufferAttachments" + } + ] + }, + "VkAttachmentDescription2": { + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)": [ + { + "vuid": "VUID-VkAttachmentDescription2-finalLayout-03061", + "text": " finalLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED" + }, + { + "vuid": "VUID-VkAttachmentDescription2-format-03294", + "text": " If format is a color format, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription2-format-03295", + "text": " If format is a depth/stencil format, initialLayout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription2-format-03296", + "text": " If format is a color format, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription2-format-03297", + "text": " If format is a depth/stencil format, finalLayout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2" + }, + { + "vuid": "VUID-VkAttachmentDescription2-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkAttachmentDescriptionStencilLayout" + }, + { + "vuid": "VUID-VkAttachmentDescription2-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkAttachmentDescription2-flags-parameter", + "text": " flags must be a valid combination of VkAttachmentDescriptionFlagBits values" + }, + { + "vuid": "VUID-VkAttachmentDescription2-format-parameter", + "text": " format must be a valid VkFormat value" + }, + { + "vuid": "VUID-VkAttachmentDescription2-samples-parameter", + "text": " samples must be a valid VkSampleCountFlagBits value" + }, + { + "vuid": "VUID-VkAttachmentDescription2-loadOp-parameter", + "text": " loadOp must be a valid VkAttachmentLoadOp value" + }, + { + "vuid": "VUID-VkAttachmentDescription2-storeOp-parameter", + "text": " storeOp must be a valid VkAttachmentStoreOp value" + }, + { + "vuid": "VUID-VkAttachmentDescription2-stencilLoadOp-parameter", + "text": " stencilLoadOp must be a valid VkAttachmentLoadOp value" + }, + { + "vuid": "VUID-VkAttachmentDescription2-stencilStoreOp-parameter", + "text": " stencilStoreOp must be a valid VkAttachmentStoreOp value" + }, + { + "vuid": "VUID-VkAttachmentDescription2-initialLayout-parameter", + "text": " initialLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-VkAttachmentDescription2-finalLayout-parameter", + "text": " finalLayout must be a valid VkImageLayout value" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-VkAttachmentDescription2-separateDepthStencilLayouts-03298", + "text": " If the separateDepthStencilLayouts feature is not enabled, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription2-separateDepthStencilLayouts-03299", + "text": " If the separateDepthStencilLayouts feature is not enabled, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription2-format-03300", + "text": " If format is a color format, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription2-format-03301", + "text": " If format is a color format, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription2-format-03302", + "text": " If format is a depth/stencil format which includes both depth and stencil aspects, and initialLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, the pNext chain must include a VkAttachmentDescriptionStencilLayout structure" + }, + { + "vuid": "VUID-VkAttachmentDescription2-format-03303", + "text": " If format is a depth/stencil format which includes both depth and stencil aspects, and finalLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, the pNext chain must include a VkAttachmentDescriptionStencilLayout structure" + }, + { + "vuid": "VUID-VkAttachmentDescription2-format-03304", + "text": " If format is a depth/stencil format which includes only the depth aspect, initialLayout must not be VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription2-format-03305", + "text": " If format is a depth/stencil format which includes only the depth aspect, finalLayout must not be VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription2-format-03306", + "text": " If format is a depth/stencil format which includes only the stencil aspect, initialLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescription2-format-03307", + "text": " If format is a depth/stencil format which includes only the stencil aspect, finalLayout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL" + } + ] + }, + "VkAttachmentDescriptionStencilLayout": { + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-VkAttachmentDescriptionStencilLayout-stencilInitialLayout-03308", + "text": " stencilInitialLayout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescriptionStencilLayout-stencilFinalLayout-03309", + "text": " stencilFinalLayout must not be VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentDescriptionStencilLayout-stencilFinalLayout-03310", + "text": " stencilFinalLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED" + }, + { + "vuid": "VUID-VkAttachmentDescriptionStencilLayout-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT" + }, + { + "vuid": "VUID-VkAttachmentDescriptionStencilLayout-stencilInitialLayout-parameter", + "text": " stencilInitialLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-VkAttachmentDescriptionStencilLayout-stencilFinalLayout-parameter", + "text": " stencilFinalLayout must be a valid VkImageLayout value" + } + ] + }, + "VkSubpassDescription2": { + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+!(VK_HUAWEI_subpass_shading)": [ + { + "vuid": "VUID-VkSubpassDescription2-pipelineBindPoint-03062", + "text": " pipelineBindPoint must be VK_PIPELINE_BIND_POINT_GRAPHICS" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_HUAWEI_subpass_shading)": [ + { + "vuid": "VUID-VkSubpassDescription2-pipelineBindPoint-04953", + "text": " pipelineBindPoint must be VK_PIPELINE_BIND_POINT_GRAPHICS or VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)": [ + { + "vuid": "VUID-VkSubpassDescription2-colorAttachmentCount-03063", + "text": " colorAttachmentCount must be less than or equal to VkPhysicalDeviceLimits::maxColorAttachments" + }, + { + "vuid": "VUID-VkSubpassDescription2-loadOp-03064", + "text": " If the first use of an attachment in this render pass is as an input attachment, and the attachment is not also used as a color or depth/stencil attachment in the same subpass, then loadOp must not be VK_ATTACHMENT_LOAD_OP_CLEAR" + }, + { + "vuid": "VUID-VkSubpassDescription2-pResolveAttachments-03065", + "text": " If pResolveAttachments is not NULL, for each resolve attachment that does not have the value VK_ATTACHMENT_UNUSED, the corresponding color attachment must not have the value VK_ATTACHMENT_UNUSED" + }, + { + "vuid": "VUID-VkSubpassDescription2-pResolveAttachments-03066", + "text": " If pResolveAttachments is not NULL, for each resolve attachment that is not VK_ATTACHMENT_UNUSED, the corresponding color attachment must not have a sample count of VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-VkSubpassDescription2-pResolveAttachments-03067", + "text": " If pResolveAttachments is not NULL, each resolve attachment that is not VK_ATTACHMENT_UNUSED must have a sample count of VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-VkSubpassDescription2-pResolveAttachments-03068", + "text": " Any given element of pResolveAttachments must have the same VkFormat as its corresponding color attachment" + }, + { + "vuid": "VUID-VkSubpassDescription2-pColorAttachments-03069", + "text": " All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have the same sample count" + }, + { + "vuid": "VUID-VkSubpassDescription2-pInputAttachments-02897", + "text": " All attachments in pInputAttachments that are not VK_ATTACHMENT_UNUSED must have image formats whose potential format features contain at least VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT or VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkSubpassDescription2-pColorAttachments-02898", + "text": " All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have image formats whose potential format features contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkSubpassDescription2-pResolveAttachments-02899", + "text": " All attachments in pResolveAttachments that are not VK_ATTACHMENT_UNUSED must have image formats whose potential format features contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkSubpassDescription2-pDepthStencilAttachment-02900", + "text": " If pDepthStencilAttachment is not NULL and the attachment is not VK_ATTACHMENT_UNUSED then it must have an image format whose potential format features contain VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkSubpassDescription2-pDepthStencilAttachment-03071", + "text": " If neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, and if pDepthStencilAttachment is not VK_ATTACHMENT_UNUSED and any attachments in pColorAttachments are not VK_ATTACHMENT_UNUSED, they must have the same sample count" + }, + { + "vuid": "VUID-VkSubpassDescription2-attachment-03073", + "text": " Each element of pPreserveAttachments must not be VK_ATTACHMENT_UNUSED" + }, + { + "vuid": "VUID-VkSubpassDescription2-pPreserveAttachments-03074", + "text": " Any given element of pPreserveAttachments must not also be an element of any other member of the subpass description" + }, + { + "vuid": "VUID-VkSubpassDescription2-layout-02528", + "text": " If any attachment is used by more than one VkAttachmentReference2 member, then each use must use the same layout" + }, + { + "vuid": "VUID-VkSubpassDescription2-None-04439", + "text": " Attachments must follow the image layout requirements based on the type of attachment it is being used as" + }, + { + "vuid": "VUID-VkSubpassDescription2-attachment-02799", + "text": " If the attachment member of any element of pInputAttachments is not VK_ATTACHMENT_UNUSED, then the aspectMask member must be a valid combination of VkImageAspectFlagBits" + }, + { + "vuid": "VUID-VkSubpassDescription2-attachment-02800", + "text": " If the attachment member of any element of pInputAttachments is not VK_ATTACHMENT_UNUSED, then the aspectMask member must not be 0" + }, + { + "vuid": "VUID-VkSubpassDescription2-attachment-02801", + "text": " If the attachment member of any element of pInputAttachments is not VK_ATTACHMENT_UNUSED, then the aspectMask member must not include VK_IMAGE_ASPECT_METADATA_BIT" + }, + { + "vuid": "VUID-VkSubpassDescription2-pDepthStencilAttachment-04440", + "text": " An attachment must not be used in both pDepthStencilAttachment and pColorAttachments" + }, + { + "vuid": "VUID-VkSubpassDescription2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2" + }, + { + "vuid": "VUID-VkSubpassDescription2-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkFragmentShadingRateAttachmentInfoKHR or VkSubpassDescriptionDepthStencilResolve" + }, + { + "vuid": "VUID-VkSubpassDescription2-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkSubpassDescription2-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkSubpassDescription2-pipelineBindPoint-parameter", + "text": " pipelineBindPoint must be a valid VkPipelineBindPoint value" + }, + { + "vuid": "VUID-VkSubpassDescription2-pInputAttachments-parameter", + "text": " If inputAttachmentCount is not 0, pInputAttachments must be a valid pointer to an array of inputAttachmentCount valid VkAttachmentReference2 structures" + }, + { + "vuid": "VUID-VkSubpassDescription2-pColorAttachments-parameter", + "text": " If colorAttachmentCount is not 0, pColorAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference2 structures" + }, + { + "vuid": "VUID-VkSubpassDescription2-pResolveAttachments-parameter", + "text": " If colorAttachmentCount is not 0, and pResolveAttachments is not NULL, pResolveAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference2 structures" + }, + { + "vuid": "VUID-VkSubpassDescription2-pDepthStencilAttachment-parameter", + "text": " If pDepthStencilAttachment is not NULL, pDepthStencilAttachment must be a valid pointer to a valid VkAttachmentReference2 structure" + }, + { + "vuid": "VUID-VkSubpassDescription2-pPreserveAttachments-parameter", + "text": " If preserveAttachmentCount is not 0, pPreserveAttachments must be a valid pointer to an array of preserveAttachmentCount uint32_t values" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_AMD_mixed_attachment_samples)": [ + { + "vuid": "VUID-VkSubpassDescription2-pColorAttachments-03070", + "text": " If the VK_AMD_mixed_attachment_samples extension is enabled, all attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have a sample count that is smaller than or equal to the sample count of pDepthStencilAttachment if it is not VK_ATTACHMENT_UNUSED" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_NVX_multiview_per_view_attributes)": [ + { + "vuid": "VUID-VkSubpassDescription2-flags-03076", + "text": " If flags includes VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX, it must also include VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_EXT_image_drm_format_modifier)": [ + { + "vuid": "VUID-VkSubpassDescription2-attachment-04563", + "text": " If the attachment member of any element of pInputAttachments is not VK_ATTACHMENT_UNUSED, then the aspectMask member must not include VK_IMAGE_ASPECT_MEMORY_PLANE{ibit}BIT_EXT for any index i" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkSubpassDescription2-inputAttachmentCount-05058", + "text": " inputAttachmentCount must be less than or equal to maxSubpassInputAttachments" + }, + { + "vuid": "VUID-VkSubpassDescription2-preserveAttachmentCount-05059", + "text": " preserveAttachmentCount must be less than or equal to maxSubpassPreserveAttachments" + } + ] + }, + "VkSubpassDescriptionDepthStencilResolve": { + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_VERSION_1_2,VK_KHR_depth_stencil_resolve)": [ + { + "vuid": "VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03177", + "text": " If pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED, pDepthStencilAttachment must not be NULL or have the value VK_ATTACHMENT_UNUSED" + }, + { + "vuid": "VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03178", + "text": " If pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED, depthResolveMode and stencilResolveMode must not both be VK_RESOLVE_MODE_NONE" + }, + { + "vuid": "VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03179", + "text": " If pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED, pDepthStencilAttachment must not have a sample count of VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03180", + "text": " If pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED, pDepthStencilResolveAttachment must have a sample count of VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-02651", + "text": " If pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED then it must have an image format whose potential format features contain VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03181", + "text": " If pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED and VkFormat of pDepthStencilResolveAttachment has a depth component, then the VkFormat of pDepthStencilAttachment must have a depth component with the same number of bits and numerical type" + }, + { + "vuid": "VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03182", + "text": " If pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED, and VkFormat of pDepthStencilResolveAttachment has a stencil component, then the VkFormat of pDepthStencilAttachment must have a stencil component with the same number of bits and numerical type" + }, + { + "vuid": "VUID-VkSubpassDescriptionDepthStencilResolve-depthResolveMode-03183", + "text": " If pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED and the VkFormat of pDepthStencilResolveAttachment has a depth component, then the value of depthResolveMode must be one of the bits set in VkPhysicalDeviceDepthStencilResolveProperties::supportedDepthResolveModes or VK_RESOLVE_MODE_NONE" + }, + { + "vuid": "VUID-VkSubpassDescriptionDepthStencilResolve-stencilResolveMode-03184", + "text": " If pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED and the VkFormat of pDepthStencilResolveAttachment has a stencil component, then the value of stencilResolveMode must be one of the bits set in VkPhysicalDeviceDepthStencilResolveProperties::supportedStencilResolveModes or VK_RESOLVE_MODE_NONE" + }, + { + "vuid": "VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03185", + "text": " If pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED, the VkFormat of pDepthStencilResolveAttachment has both depth and stencil components, VkPhysicalDeviceDepthStencilResolveProperties::independentResolve is VK_FALSE, and VkPhysicalDeviceDepthStencilResolveProperties::independentResolveNone is VK_FALSE, then the values of depthResolveMode and stencilResolveMode must be identical" + }, + { + "vuid": "VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03186", + "text": " If pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED, the VkFormat of pDepthStencilResolveAttachment has both depth and stencil components, VkPhysicalDeviceDepthStencilResolveProperties::independentResolve is VK_FALSE and VkPhysicalDeviceDepthStencilResolveProperties::independentResolveNone is VK_TRUE, then the values of depthResolveMode and stencilResolveMode must be identical or one of them must be VK_RESOLVE_MODE_NONE" + }, + { + "vuid": "VUID-VkSubpassDescriptionDepthStencilResolve-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE" + }, + { + "vuid": "VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-parameter", + "text": " If pDepthStencilResolveAttachment is not NULL, pDepthStencilResolveAttachment must be a valid pointer to a valid VkAttachmentReference2 structure" + } + ] + }, + "VkFragmentShadingRateAttachmentInfoKHR": { + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-VkFragmentShadingRateAttachmentInfoKHR-pFragmentShadingRateAttachment-04524", + "text": " If pFragmentShadingRateAttachment is not NULL and its attachment member is not VK_ATTACHMENT_UNUSED, its layout member must be equal to VK_IMAGE_LAYOUT_GENERAL or VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR" + }, + { + "vuid": "VUID-VkFragmentShadingRateAttachmentInfoKHR-pFragmentShadingRateAttachment-04525", + "text": " If pFragmentShadingRateAttachment is not NULL and its attachment member is not VK_ATTACHMENT_UNUSED, shadingRateAttachmentTexelSize.width must be a power of two value" + }, + { + "vuid": "VUID-VkFragmentShadingRateAttachmentInfoKHR-pFragmentShadingRateAttachment-04526", + "text": " If pFragmentShadingRateAttachment is not NULL and its attachment member is not VK_ATTACHMENT_UNUSED, shadingRateAttachmentTexelSize.width must be less than or equal to maxFragmentShadingRateAttachmentTexelSize.width" + }, + { + "vuid": "VUID-VkFragmentShadingRateAttachmentInfoKHR-pFragmentShadingRateAttachment-04527", + "text": " If pFragmentShadingRateAttachment is not NULL and its attachment member is not VK_ATTACHMENT_UNUSED, shadingRateAttachmentTexelSize.width must be greater than or equal to minFragmentShadingRateAttachmentTexelSize.width" + }, + { + "vuid": "VUID-VkFragmentShadingRateAttachmentInfoKHR-pFragmentShadingRateAttachment-04528", + "text": " If pFragmentShadingRateAttachment is not NULL and its attachment member is not VK_ATTACHMENT_UNUSED, shadingRateAttachmentTexelSize.height must be a power of two value" + }, + { + "vuid": "VUID-VkFragmentShadingRateAttachmentInfoKHR-pFragmentShadingRateAttachment-04529", + "text": " If pFragmentShadingRateAttachment is not NULL and its attachment member is not VK_ATTACHMENT_UNUSED, shadingRateAttachmentTexelSize.height must be less than or equal to maxFragmentShadingRateAttachmentTexelSize.height" + }, + { + "vuid": "VUID-VkFragmentShadingRateAttachmentInfoKHR-pFragmentShadingRateAttachment-04530", + "text": " If pFragmentShadingRateAttachment is not NULL and its attachment member is not VK_ATTACHMENT_UNUSED, shadingRateAttachmentTexelSize.height must be greater than or equal to minFragmentShadingRateAttachmentTexelSize.height" + }, + { + "vuid": "VUID-VkFragmentShadingRateAttachmentInfoKHR-pFragmentShadingRateAttachment-04531", + "text": " If pFragmentShadingRateAttachment is not NULL and its attachment member is not VK_ATTACHMENT_UNUSED, the quotient of shadingRateAttachmentTexelSize.width and shadingRateAttachmentTexelSize.height must be less than or equal to maxFragmentShadingRateAttachmentTexelSizeAspectRatio" + }, + { + "vuid": "VUID-VkFragmentShadingRateAttachmentInfoKHR-pFragmentShadingRateAttachment-04532", + "text": " If pFragmentShadingRateAttachment is not NULL and its attachment member is not VK_ATTACHMENT_UNUSED, the quotient of shadingRateAttachmentTexelSize.height and shadingRateAttachmentTexelSize.width must be less than or equal to maxFragmentShadingRateAttachmentTexelSizeAspectRatio" + }, + { + "vuid": "VUID-VkFragmentShadingRateAttachmentInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR" + }, + { + "vuid": "VUID-VkFragmentShadingRateAttachmentInfoKHR-pFragmentShadingRateAttachment-parameter", + "text": " If pFragmentShadingRateAttachment is not NULL, pFragmentShadingRateAttachment must be a valid pointer to a valid VkAttachmentReference2 structure" + } + ] + }, + "VkAttachmentReference2": { + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)": [ + { + "vuid": "VUID-VkAttachmentReference2-layout-03077", + "text": " If attachment is not VK_ATTACHMENT_UNUSED, layout must not be VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_PREINITIALIZED, or VK_IMAGE_LAYOUT_PRESENT_SRC_KHR" + }, + { + "vuid": "VUID-VkAttachmentReference2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2" + }, + { + "vuid": "VUID-VkAttachmentReference2-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkAttachmentReferenceStencilLayout" + }, + { + "vuid": "VUID-VkAttachmentReference2-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkAttachmentReference2-layout-parameter", + "text": " layout must be a valid VkImageLayout value" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-VkAttachmentReference2-separateDepthStencilLayouts-03313", + "text": " If the separateDepthStencilLayouts feature is not enabled, and attachment is not VK_ATTACHMENT_UNUSED, layout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL," + }, + { + "vuid": "VUID-VkAttachmentReference2-attachment-04754", + "text": " If attachment is not VK_ATTACHMENT_UNUSED, and the format of the referenced attachment is a color format, layout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentReference2-attachment-04755", + "text": " If attachment is not VK_ATTACHMENT_UNUSED, and the format of the referenced attachment is a depth/stencil format which includes both depth and stencil aspects, and layout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, the pNext chain must include a VkAttachmentReferenceStencilLayout structure" + }, + { + "vuid": "VUID-VkAttachmentReference2-attachment-04756", + "text": " If attachment is not VK_ATTACHMENT_UNUSED, and the format of the referenced attachment is a depth/stencil format which includes only the depth aspect, layout must not be VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + }, + { + "vuid": "VUID-VkAttachmentReference2-attachment-04757", + "text": " If attachment is not VK_ATTACHMENT_UNUSED, and the format of the referenced attachment is a depth/stencil format which includes only the stencil aspect, layout must not be VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL" + } + ] + }, + "VkAttachmentReferenceStencilLayout": { + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-VkAttachmentReferenceStencilLayout-stencilLayout-03318", + "text": " stencilLayout must not be VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_PREINITIALIZED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_PRESENT_SRC_KHR" + }, + { + "vuid": "VUID-VkAttachmentReferenceStencilLayout-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT" + }, + { + "vuid": "VUID-VkAttachmentReferenceStencilLayout-stencilLayout-parameter", + "text": " stencilLayout must be a valid VkImageLayout value" + } + ] + }, + "VkSubpassDependency2": { + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)": [ + { + "vuid": "VUID-VkSubpassDependency2-srcStageMask-04090", + "text": " If the geometry shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-VkSubpassDependency2-srcStageMask-04091", + "text": " If the tessellation shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-VkSubpassDependency2-dstStageMask-04090", + "text": " If the geometry shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-VkSubpassDependency2-dstStageMask-04091", + "text": " If the tessellation shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-VkSubpassDependency2-srcSubpass-03084", + "text": " srcSubpass must be less than or equal to dstSubpass, unless one of them is VK_SUBPASS_EXTERNAL, to avoid cyclic dependencies and ensure a valid execution order" + }, + { + "vuid": "VUID-VkSubpassDependency2-srcSubpass-03085", + "text": " srcSubpass and dstSubpass must not both be equal to VK_SUBPASS_EXTERNAL" + }, + { + "vuid": "VUID-VkSubpassDependency2-srcSubpass-03087", + "text": " If srcSubpass is equal to dstSubpass and not all of the stages in srcStageMask and dstStageMask are framebuffer-space stages, the logically latest pipeline stage in srcStageMask must be logically earlier than or equal to the logically earliest pipeline stage in dstStageMask" + }, + { + "vuid": "VUID-VkSubpassDependency2-srcAccessMask-03088", + "text": " Any access flag included in srcAccessMask must be supported by one of the pipeline stages in srcStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-VkSubpassDependency2-dstAccessMask-03089", + "text": " Any access flag included in dstAccessMask must be supported by one of the pipeline stages in dstStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-VkSubpassDependency2-dependencyFlags-03090", + "text": " If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, srcSubpass must not be equal to VK_SUBPASS_EXTERNAL" + }, + { + "vuid": "VUID-VkSubpassDependency2-dependencyFlags-03091", + "text": " If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, dstSubpass must not be equal to VK_SUBPASS_EXTERNAL" + }, + { + "vuid": "VUID-VkSubpassDependency2-srcSubpass-02245", + "text": " If srcSubpass equals dstSubpass, and srcStageMask and dstStageMask both include a framebuffer-space stage, then dependencyFlags must include VK_DEPENDENCY_BY_REGION_BIT" + }, + { + "vuid": "VUID-VkSubpassDependency2-viewOffset-02530", + "text": " If viewOffset is not equal to 0, srcSubpass must not be equal to dstSubpass" + }, + { + "vuid": "VUID-VkSubpassDependency2-dependencyFlags-03092", + "text": " If dependencyFlags does not include VK_DEPENDENCY_VIEW_LOCAL_BIT, viewOffset must be 0" + }, + { + "vuid": "VUID-VkSubpassDependency2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2" + }, + { + "vuid": "VUID-VkSubpassDependency2-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkMemoryBarrier2KHR" + }, + { + "vuid": "VUID-VkSubpassDependency2-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkSubpassDependency2-srcStageMask-parameter", + "text": " srcStageMask must be a valid combination of VkPipelineStageFlagBits values" + }, + { + "vuid": "VUID-VkSubpassDependency2-dstStageMask-parameter", + "text": " dstStageMask must be a valid combination of VkPipelineStageFlagBits values" + }, + { + "vuid": "VUID-VkSubpassDependency2-srcAccessMask-parameter", + "text": " srcAccessMask must be a valid combination of VkAccessFlagBits values" + }, + { + "vuid": "VUID-VkSubpassDependency2-dstAccessMask-parameter", + "text": " dstAccessMask must be a valid combination of VkAccessFlagBits values" + }, + { + "vuid": "VUID-VkSubpassDependency2-dependencyFlags-parameter", + "text": " dependencyFlags must be a valid combination of VkDependencyFlagBits values" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_EXT_conditional_rendering)": [ + { + "vuid": "VUID-VkSubpassDependency2-srcStageMask-04092", + "text": " If the conditional rendering feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT" + }, + { + "vuid": "VUID-VkSubpassDependency2-dstStageMask-04092", + "text": " If the conditional rendering feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkSubpassDependency2-srcStageMask-04093", + "text": " If the fragment density map feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + }, + { + "vuid": "VUID-VkSubpassDependency2-dstStageMask-04093", + "text": " If the fragment density map feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-VkSubpassDependency2-srcStageMask-04094", + "text": " If the transform feedback feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT" + }, + { + "vuid": "VUID-VkSubpassDependency2-dstStageMask-04094", + "text": " If the transform feedback feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-VkSubpassDependency2-srcStageMask-04095", + "text": " If the mesh shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV" + }, + { + "vuid": "VUID-VkSubpassDependency2-srcStageMask-04096", + "text": " If the task shaders feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV" + }, + { + "vuid": "VUID-VkSubpassDependency2-dstStageMask-04095", + "text": " If the mesh shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV" + }, + { + "vuid": "VUID-VkSubpassDependency2-dstStageMask-04096", + "text": " If the task shaders feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkSubpassDependency2-srcStageMask-04097", + "text": " If the shading rate image feature is not enabled, pname:srcStageMask must not contain VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV" + }, + { + "vuid": "VUID-VkSubpassDependency2-dstStageMask-04097", + "text": " If the shading rate image feature is not enabled, pname:dstStageMask must not contain VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-VkSubpassDependency2-srcStageMask-03937", + "text": " If the synchronization2 feature is not enabled, pname:srcStageMask must not be 0" + }, + { + "vuid": "VUID-VkSubpassDependency2-dstStageMask-03937", + "text": " If the synchronization2 feature is not enabled, pname:dstStageMask must not be 0" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+!(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-VkSubpassDependency2-srcStageMask-04996", + "text": " pname:srcStageMask must not be 0" + }, + { + "vuid": "VUID-VkSubpassDependency2-dstStageMask-04996", + "text": " pname:dstStageMask must not be 0" + } + ] + }, + "vkDestroyRenderPass": { + "core": [ + { + "vuid": "VUID-vkDestroyRenderPass-renderPass-00873", + "text": " All submitted commands that refer to renderPass must have completed execution" + }, + { + "vuid": "VUID-vkDestroyRenderPass-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyRenderPass-renderPass-parameter", + "text": " If renderPass is not VK_NULL_HANDLE, renderPass must be a valid VkRenderPass handle" + }, + { + "vuid": "VUID-vkDestroyRenderPass-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyRenderPass-renderPass-parent", + "text": " If renderPass is a valid handle, it must have been created, allocated, or retrieved from device" + } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyRenderPass-renderPass-00874", + "text": " If VkAllocationCallbacks were provided when renderPass was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyRenderPass-renderPass-00875", + "text": " If no VkAllocationCallbacks were provided when renderPass was created, pAllocator must be NULL" + } + ] + }, + "vkCreateFramebuffer": { + "core": [ + { + "vuid": "VUID-vkCreateFramebuffer-pCreateInfo-02777", + "text": " If pCreateInfo->flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, and attachmentCount is not 0, each element of pCreateInfo->pAttachments must have been created on device" + }, + { + "vuid": "VUID-vkCreateFramebuffer-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateFramebuffer-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkFramebufferCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateFramebuffer-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateFramebuffer-pFramebuffer-parameter", + "text": " pFramebuffer must be a valid pointer to a VkFramebuffer handle" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateFramebuffer-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ] + }, + "VkFramebufferCreateInfo": { + "core": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-attachmentCount-00876", + "text": " If renderpass is not VK_NULL_HANDLE, attachmentCount must be equal to the attachment count specified in renderPass" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-02778", + "text": " If renderpass is not VK_NULL_HANDLE, flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, and attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkImageView handles" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00877", + "text": " If renderpass is not VK_NULL_HANDLE and flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as a color attachment or resolve attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-02633", + "text": " If renderpass is not VK_NULL_HANDLE and flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as a depth/stencil attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00879", + "text": " If renderpass is not VK_NULL_HANDLE and renderpass is not VK_NULL_HANDLE, flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as an input attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00880", + "text": " If renderpass is not VK_NULL_HANDLE and flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments must have been created with a VkFormat value that matches the VkFormat specified by the corresponding VkAttachmentDescription in renderPass" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00881", + "text": " If renderpass is not VK_NULL_HANDLE and flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments must have been created with a samples value that matches the samples value specified by the corresponding VkAttachmentDescription in renderPass" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-04533", + "text": " If renderpass is not VK_NULL_HANDLE and flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as an input, color, resolve, or depth/stencil attachment by renderPass must have been created with a VkImageCreateInfo::width greater than or equal to width" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-04534", + "text": " If renderpass is not VK_NULL_HANDLE and flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as an input, color, resolve, or depth/stencil attachment by renderPass must have been created with a VkImageCreateInfo::height greater than or equal to height" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-04535", + "text": " If renderpass is not VK_NULL_HANDLE and flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as an input, color, resolve, or depth/stencil attachment by renderPass must have been created with a VkImageViewCreateInfo::subresourceRange.layerCount greater than or equal to layers" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00883", + "text": " If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments must only specify a single mip level" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00884", + "text": " If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments must have been created with the identity swizzle" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-width-00885", + "text": " width must be greater than 0" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-width-00886", + "text": " width must be less than or equal to maxFramebufferWidth" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-height-00887", + "text": " height must be greater than 0" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-height-00888", + "text": " height must be less than or equal to maxFramebufferHeight" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-layers-00889", + "text": " layers must be greater than 0" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-layers-00890", + "text": " layers must be less than or equal to maxFramebufferLayers" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-04113", + "text": " If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments must have been created with VkImageViewCreateInfo::viewType not equal to VK_IMAGE_VIEW_TYPE_3D" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkFramebufferAttachmentsCreateInfo" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkFramebufferCreateFlagBits values" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-renderPass-parameter", + "text": " renderPass must be a valid VkRenderPass handle" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-commonparent", + "text": " Both of renderPass, and the elements of pAttachments that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_2,VK_KHR_depth_stencil_resolve)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-02634", + "text": " If renderpass is not VK_NULL_HANDLE and flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as a depth/stencil resolve attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-02552", + "text": " If renderpass is not VK_NULL_HANDLE, each element of pAttachments that is used as a fragment density map attachment by renderPass must not have been created with a flags value including VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-renderPass-02553", + "text": " If renderpass is not VK_NULL_HANDLE, renderPass has a fragment density map attachment, and non-subsample image feature is not enabled, each element of pAttachments must have been created with a flags value including VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT unless that element is the fragment density map attachment" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-02555", + "text": " If renderpass is not VK_NULL_HANDLE and flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, an element of pAttachments that is referenced by fragmentDensityMapAttachment must have a width at least as large as \\(\\left\\lceil{\\frac{width}{maxFragmentDensityTexelSize_{width}}}\\right\\rceil\\)" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-02556", + "text": " If renderpass is not VK_NULL_HANDLE and flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, an element of pAttachments that is referenced by fragmentDensityMapAttachment must have a height at least as large as \\(\\left\\lceil{\\frac{height}{maxFragmentDensityTexelSize_{height}}}\\right\\rceil\\)" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-renderPass-04536", + "text": " If renderpass is not VK_NULL_HANDLE and renderPass was specified with non-zero view masks, each element of pAttachments that is used as an input, color, resolve, or depth/stencil attachment by renderPass must have a layerCount greater than the index of the most significant bit set in any of those view masks" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-renderPass-02531", + "text": " If renderpass is not VK_NULL_HANDLE and renderPass was specified with non-zero view masks, layers must be 1" + } + ], + "(VK_EXT_fragment_density_map)+!(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-02744", + "text": " If renderpass is not VK_NULL_HANDLE, an element of pAttachments that is referenced by fragmentDensityMapAttachment must have a layerCount equal to 1" + } + ], + "(VK_EXT_fragment_density_map)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-renderPass-02746", + "text": " If renderpass is not VK_NULL_HANDLE and renderPass was specified with non-zero view masks, each element of pAttachments that is referenced by fragmentDensityMapAttachment must have a layerCount equal to 1 or greater than the index of the most significant bit set in any of those view masks" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-renderPass-02747", + "text": " If renderpass is not VK_NULL_HANDLE and renderPass was not specified with non-zero view masks, each element of pAttachments that is referenced by fragmentDensityMapAttachment must have a layerCount equal to 1" + } + ], + "(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-04537", + "text": " If renderpass is not VK_NULL_HANDLE and flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, and renderPass was specified with non-zero view masks, each element of pAttachments that is used as a fragment shading rate attachment by renderPass must have a layerCount that is either 1, or greater than the index of the most significant bit set in any of those view masks" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-04538", + "text": " If renderpass is not VK_NULL_HANDLE and flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, and renderPass was not specified with non-zero view masks, each element of pAttachments that is used as a fragment shading rate attachment by renderPass must have a layerCount that is either 1, or greater than layers" + } + ], + "(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-04539", + "text": " If renderpass is not VK_NULL_HANDLE and flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, an element of pAttachments that is used as a fragment shading rate attachment must have a width at least as large as {lceil}width / texelWidth{rceil}, where texelWidth is the largest value of shadingRateAttachmentTexelSize.width in a VkFragmentShadingRateAttachmentInfoKHR which references that attachment" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-04540", + "text": " If renderpass is not VK_NULL_HANDLE and flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, an element of pAttachments that is used as a fragment shading rate attachment must have a height at least as large as {lceil}height / texelHeight{rceil}, where texelHeight is the largest value of shadingRateAttachmentTexelSize.height in a VkFragmentShadingRateAttachmentInfoKHR which references that attachment" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-04548", + "text": " If renderpass is not VK_NULL_HANDLE and flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as a fragment shading rate attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-pAttachments-00891", + "text": " If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is a 2D or 2D array image view taken from a 3D image must not be a depth/stencil format" + } + ], + "(VK_VERSION_1_2,VK_KHR_imageless_framebuffer)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-03189", + "text": " If the imageless framebuffer feature is not enabled, flags must not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-03190", + "text": " If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the pNext chain must include a VkFramebufferAttachmentsCreateInfo structure" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-03191", + "text": " If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the attachmentImageInfoCount member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain must be equal to either zero or attachmentCount" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-04541", + "text": " If renderpass is not VK_NULL_HANDLE and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the width member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain that is used as an input, color, resolve or depth/stencil attachment in renderPass must be greater than or equal to width" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-04542", + "text": " If renderpass is not VK_NULL_HANDLE and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the height member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain that is used as an input, color, resolve or depth/stencil attachment in renderPass must be greater than or equal to height" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-03201", + "text": " If renderpass is not VK_NULL_HANDLE and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the usage member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain that refers to an attachment used as a color attachment or resolve attachment by renderPass must include VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-03202", + "text": " If renderpass is not VK_NULL_HANDLE and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the usage member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain that refers to an attachment used as a depth/stencil attachment by renderPass must include VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-03204", + "text": " If renderpass is not VK_NULL_HANDLE and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the usage member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain that refers to an attachment used as an input attachment by renderPass must include VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-03205", + "text": " If renderpass is not VK_NULL_HANDLE and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, at least one element of the pViewFormats member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain must be equal to the corresponding value of VkAttachmentDescription::format used to create renderPass" + } + ], + "(VK_VERSION_1_2,VK_KHR_imageless_framebuffer)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-03196", + "text": " If renderpass is not VK_NULL_HANDLE and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the width member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain that is referenced by VkRenderPassFragmentDensityMapCreateInfoEXT::fragmentDensityMapAttachment in renderPass must be greater than or equal to \\(\\left\\lceil{\\frac{width}{maxFragmentDensityTexelSize_{width}}}\\right\\rceil\\)" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-03197", + "text": " If renderpass is not VK_NULL_HANDLE and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the height member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain that is referenced by VkRenderPassFragmentDensityMapCreateInfoEXT::fragmentDensityMapAttachment in renderPass must be greater than or equal to \\(\\left\\lceil{\\frac{height}{maxFragmentDensityTexelSize_{height}}}\\right\\rceil\\)" + } + ], + "(VK_VERSION_1_2,VK_KHR_imageless_framebuffer)+(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-04543", + "text": " If renderpass is not VK_NULL_HANDLE and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the width member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain that is used as a fragment shading rate attachment must be greater than or equal to {lceil}width / texelWidth{rceil}, where texelWidth is the largest value of shadingRateAttachmentTexelSize.width in a VkFragmentShadingRateAttachmentInfoKHR which references that attachment" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-04544", + "text": " If renderpass is not VK_NULL_HANDLE and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the height member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain that is used as a fragment shading rate attachment must be greater than or equal to {lceil}height / texelHeight{rceil}, where texelHeight is the largest value of shadingRateAttachmentTexelSize.height in a VkFragmentShadingRateAttachmentInfoKHR which references that attachment" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-04545", + "text": " If renderpass is not VK_NULL_HANDLE and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the layerCount member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain that is used as a fragment shading rate attachment must be either 1, or greater than or equal to layers" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-04587", + "text": " If renderpass is not VK_NULL_HANDLE, flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, and renderPass was specified with non-zero view masks, each element of pAttachments that is used as a fragment shading rate attachment by renderPass must have a layerCount that is either 1, or greater than the index of the most significant bit set in any of those view masks" + } + ], + "(VK_VERSION_1_2,VK_KHR_imageless_framebuffer)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-renderPass-03198", + "text": " If renderpass is not VK_NULL_HANDLE, multiview is enabled for renderPass, and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the layerCount member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain used as an input, color, resolve, or depth/stencil attachment in renderPass must be greater than the maximum bit index set in the view mask in the subpasses in which it is used in renderPass" + }, + { + "vuid": "VUID-VkFramebufferCreateInfo-renderPass-04546", + "text": " If renderpass is not VK_NULL_HANDLE, multiview is not enabled for renderPass, and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the layerCount member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain used as an input, color, resolve, or depth/stencil attachment in renderPass must be greater than or equal to layers" + } + ], + "(VK_VERSION_1_2,VK_KHR_imageless_framebuffer)+!(VK_VERSION_1_1+VK_KHR_multiview)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-04547", + "text": " If renderpass is not VK_NULL_HANDLE and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the layerCount member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain used as an input, color, resolve, or depth/stencil attachment in pRenderPass must be greater than or equal to layers" + } + ], + "(VK_VERSION_1_2,VK_KHR_imageless_framebuffer)+(VK_KHR_depth_stencil_resolve)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-03203", + "text": " If renderpass is not VK_NULL_HANDLE and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the usage member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain that refers to an attachment used as a depth/stencil resolve attachment by renderPass must include VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + } + ], + "(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_2,VK_KHR_imageless_framebuffer)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-flags-04549", + "text": " If renderpass is not VK_NULL_HANDLE and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the usage member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain that refers to an attachment used as a fragment shading rate attachment by renderPass must include VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkFramebufferCreateInfo-attachmentCount-05060", + "text": " attachmentCount must be less than or equal to maxFramebufferAttachments" + } + ] + }, + "VkFramebufferAttachmentsCreateInfo": { + "(VK_VERSION_1_2,VK_KHR_imageless_framebuffer)": [ + { + "vuid": "VUID-VkFramebufferAttachmentsCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO" + }, + { + "vuid": "VUID-VkFramebufferAttachmentsCreateInfo-pAttachmentImageInfos-parameter", + "text": " If attachmentImageInfoCount is not 0, pAttachmentImageInfos must be a valid pointer to an array of attachmentImageInfoCount valid VkFramebufferAttachmentImageInfo structures" + } + ] + }, + "VkFramebufferAttachmentImageInfo": { + "(VK_VERSION_1_2,VK_KHR_imageless_framebuffer)": [ + { + "vuid": "VUID-VkFramebufferAttachmentImageInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO" + }, + { + "vuid": "VUID-VkFramebufferAttachmentImageInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkFramebufferAttachmentImageInfo-flags-parameter", + "text": " flags must be a valid combination of VkImageCreateFlagBits values" + }, + { + "vuid": "VUID-VkFramebufferAttachmentImageInfo-usage-parameter", + "text": " usage must be a valid combination of VkImageUsageFlagBits values" + }, + { + "vuid": "VUID-VkFramebufferAttachmentImageInfo-usage-requiredbitmask", + "text": " usage must not be 0" + }, + { + "vuid": "VUID-VkFramebufferAttachmentImageInfo-pViewFormats-parameter", + "text": " If viewFormatCount is not 0, pViewFormats must be a valid pointer to an array of viewFormatCount valid VkFormat values" + } + ] + }, + "vkDestroyFramebuffer": { + "core": [ + { + "vuid": "VUID-vkDestroyFramebuffer-framebuffer-00892", + "text": " All submitted commands that refer to framebuffer must have completed execution" + }, + { + "vuid": "VUID-vkDestroyFramebuffer-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyFramebuffer-framebuffer-parameter", + "text": " If framebuffer is not VK_NULL_HANDLE, framebuffer must be a valid VkFramebuffer handle" + }, + { + "vuid": "VUID-vkDestroyFramebuffer-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyFramebuffer-framebuffer-parent", + "text": " If framebuffer is a valid handle, it must have been created, allocated, or retrieved from device" + } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyFramebuffer-framebuffer-00893", + "text": " If VkAllocationCallbacks were provided when framebuffer was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyFramebuffer-framebuffer-00894", + "text": " If no VkAllocationCallbacks were provided when framebuffer was created, pAllocator must be NULL" + } + ] + }, + "vkCmdBeginRenderPass": { + "core": [ + { + "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-00895", + "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-00897", + "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-00898", + "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_TRANSFER_SRC_BIT" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-00899", + "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_TRANSFER_DST_BIT" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-00900", + "text": " If the initialLayout member of any of the VkAttachmentDescription structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is not VK_IMAGE_LAYOUT_UNDEFINED, then each such initialLayout must be equal to the current layout of the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-srcStageMask-06451", + "text": " The srcStageMask members of any element of the pDependencies member of VkRenderPassCreateInfo used to create renderPass must be supported by the capabilities of the queue family identified by the queueFamilyIndex member of the VkCommandPoolCreateInfo used to create the command pool which commandBuffer was allocated from" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-dstStageMask-06452", + "text": " The dstStageMask members of any element of the pDependencies member of VkRenderPassCreateInfo used to create renderPass must be supported by the capabilities of the queue family identified by the queueFamilyIndex member of the VkCommandPoolCreateInfo used to create the command pool which commandBuffer was allocated from" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-framebuffer-02532", + "text": " For any attachment in framebuffer that is used by renderPass and is bound to memory locations that are also bound to another attachment used by renderPass, and if at least one of those uses causes either attachment to be written to, both attachments must have had the VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT set" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-pRenderPassBegin-parameter", + "text": " pRenderPassBegin must be a valid pointer to a valid VkRenderPassBeginInfo structure" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-contents-parameter", + "text": " contents must be a valid VkSubpassContents value" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-bufferlevel", + "text": " commandBuffer must be a primary VkCommandBuffer" + } + ], + "!(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-00896", + "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-01758", + "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance2)+(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-vkCmdBeginRenderPass-initialLayout-02842", + "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass-stencilInitialLayout-02843", + "text": " If any of the stencilInitialLayout or stencilFinalLayout member of the VkAttachmentDescriptionStencilLayout structures or the stencilLayout member of the VkAttachmentReferenceStencilLayout structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + } + ] + }, + "vkCmdBeginRenderPass2": { + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)": [ + { + "vuid": "VUID-vkCmdBeginRenderPass2-framebuffer-02779", + "text": " Both the framebuffer and renderPass members of pRenderPassBegin must have been created on the same VkDevice that commandBuffer was allocated on" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass2-initialLayout-03094", + "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass2-initialLayout-03096", + "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass2-initialLayout-03097", + "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass2-initialLayout-03098", + "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_TRANSFER_SRC_BIT" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass2-initialLayout-03099", + "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_TRANSFER_DST_BIT" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass2-initialLayout-03100", + "text": " If the initialLayout member of any of the VkAttachmentDescription structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is not VK_IMAGE_LAYOUT_UNDEFINED, then each such initialLayout must be equal to the current layout of the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass2-srcStageMask-06453", + "text": " The srcStageMask members of any element of the pDependencies member of VkRenderPassCreateInfo used to create renderPass must be supported by the capabilities of the queue family identified by the queueFamilyIndex member of the VkCommandPoolCreateInfo used to create the command pool which commandBuffer was allocated from" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass2-dstStageMask-06454", + "text": " The dstStageMask members of any element of the pDependencies member of VkRenderPassCreateInfo used to create renderPass must be supported by the capabilities of the queue family identified by the queueFamilyIndex member of the VkCommandPoolCreateInfo used to create the command pool which commandBuffer was allocated from" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass2-framebuffer-02533", + "text": " For any attachment in framebuffer that is used by renderPass and is bound to memory locations that are also bound to another attachment used by renderPass, and if at least one of those uses causes either attachment to be written to, both attachments must have had the VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT set" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass2-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass2-pRenderPassBegin-parameter", + "text": " pRenderPassBegin must be a valid pointer to a valid VkRenderPassBeginInfo structure" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass2-pSubpassBeginInfo-parameter", + "text": " pSubpassBeginInfo must be a valid pointer to a valid VkSubpassBeginInfo structure" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass2-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass2-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass2-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass2-bufferlevel", + "text": " commandBuffer must be a primary VkCommandBuffer" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-vkCmdBeginRenderPass2-initialLayout-02844", + "text": " If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-vkCmdBeginRenderPass2-stencilInitialLayout-02845", + "text": " If any of the stencilInitialLayout or stencilFinalLayout member of the VkAttachmentDescriptionStencilLayout structures or the stencilLayout member of the VkAttachmentReferenceStencilLayout structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + } + ] + }, + "VkRenderPassBeginInfo": { + "core": [ + { + "vuid": "VUID-VkRenderPassBeginInfo-clearValueCount-00902", + "text": " clearValueCount must be greater than the largest attachment index in renderPass specifying a loadOp (or stencilLoadOp, if the attachment has a depth/stencil format) of VK_ATTACHMENT_LOAD_OP_CLEAR" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-clearValueCount-04962", + "text": " If clearValueCount is not 0, pClearValues must be a valid pointer to an array of clearValueCount VkClearValue unions" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-renderPass-00904", + "text": " renderPass must be compatible with the renderPass member of the VkFramebufferCreateInfo structure specified when creating framebuffer" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupRenderPassBeginInfo, VkRenderPassAttachmentBeginInfo, or VkRenderPassSampleLocationsBeginInfoEXT" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-renderPass-parameter", + "text": " renderPass must be a valid VkRenderPass handle" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-parameter", + "text": " framebuffer must be a valid VkFramebuffer handle" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-commonparent", + "text": " Both of framebuffer, and renderPass must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "!(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkRenderPassBeginInfo-renderArea-02846", + "text": " renderArea.offset.x must be greater than or equal to 0" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-renderArea-02847", + "text": " renderArea.offset.y must be greater than or equal to 0" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-renderArea-02848", + "text": " renderArea.offset.x + renderArea.extent.width must be less than or equal to VkFramebufferCreateInfo::width the framebuffer was created with" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-renderArea-02849", + "text": " renderArea.offset.y + renderArea.extent.height must be less than or equal to VkFramebufferCreateInfo::height the framebuffer was created with" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkRenderPassBeginInfo-pNext-02850", + "text": " If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0, renderArea.offset.x must be greater than or equal to 0" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-pNext-02851", + "text": " If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0, renderArea.offset.y must be greater than or equal to 0" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-pNext-02852", + "text": " If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0, renderArea.offset.x + renderArea.extent.width must be less than or equal to VkFramebufferCreateInfo::width the framebuffer was created with" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-pNext-02853", + "text": " If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0, renderArea.offset.y + renderArea.extent.height must be less than or equal to VkFramebufferCreateInfo::height the framebuffer was created with" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-pNext-02856", + "text": " If the pNext chain contains VkDeviceGroupRenderPassBeginInfo, offset.x + extent.width of each element of pDeviceRenderAreas must be less than or equal to VkFramebufferCreateInfo::width the framebuffer was created with" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-pNext-02857", + "text": " If the pNext chain contains VkDeviceGroupRenderPassBeginInfo, offset.y + extent.height of each element of pDeviceRenderAreas must be less than or equal to VkFramebufferCreateInfo::height the framebuffer was created with" + } + ], + "(VK_VERSION_1_2,VK_KHR_imageless_framebuffer)": [ + { + "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-03207", + "text": " If framebuffer was created with a VkFramebufferCreateInfo::flags value that did not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, and the pNext chain includes a VkRenderPassAttachmentBeginInfo structure, its attachmentCount must be zero" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-03208", + "text": " If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the attachmentCount of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be equal to the value of VkFramebufferAttachmentsCreateInfo::attachmentImageInfoCount used to create framebuffer" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-02780", + "text": " If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must have been created on the same VkDevice as framebuffer and renderPass" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-03209", + "text": " If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView of an image created with a value of VkImageCreateInfo::flags equal to the flags member of the corresponding element of VkFramebufferAttachmentsCreateInfo::pAttachmentImageInfos used to create framebuffer" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-04627", + "text": " If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView with an inherited usage equal to the usage member of the corresponding element of VkFramebufferAttachmentsCreateInfo::pAttachmentImageInfos used to create framebuffer" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-03211", + "text": " If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView with a width equal to the width member of the corresponding element of VkFramebufferAttachmentsCreateInfo::pAttachmentImageInfos used to create framebuffer" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-03212", + "text": " If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView with a height equal to the height member of the corresponding element of VkFramebufferAttachmentsCreateInfo::pAttachmentImageInfos used to create framebuffer" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-03213", + "text": " If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView of an image created with a value of VkImageViewCreateInfo::subresourceRange.layerCount equal to the layerCount member of the corresponding element of VkFramebufferAttachmentsCreateInfo::pAttachmentImageInfos used to create framebuffer" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-03214", + "text": " If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView of an image created with a value of VkImageFormatListCreateInfo::viewFormatCount equal to the viewFormatCount member of the corresponding element of VkFramebufferAttachmentsCreateInfo::pAttachmentImageInfos used to create framebuffer" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-03215", + "text": " If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView of an image created with a set of elements in VkImageFormatListCreateInfo::pViewFormats equal to the set of elements in the pViewFormats member of the corresponding element of VkFramebufferAttachmentsCreateInfo::pAttachmentImageInfos used to create framebuffer" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-03216", + "text": " If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView of an image created with a value of VkImageViewCreateInfo::format equal to the corresponding value of VkAttachmentDescription::format in renderPass" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-framebuffer-03217", + "text": " If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of the pAttachments member of a VkRenderPassAttachmentBeginInfo structure included in the pNext chain must be a VkImageView of an image created with a value of VkImageCreateInfo::samples equal to the corresponding value of VkAttachmentDescription::samples in renderPass" + } + ], + "(VK_QCOM_render_pass_transform)": [ + { + "vuid": "VUID-VkRenderPassBeginInfo-pNext-02869", + "text": " If the pNext chain includes VkRenderPassTransformBeginInfoQCOM, renderArea.offset must equal (0,0)" + }, + { + "vuid": "VUID-VkRenderPassBeginInfo-pNext-02870", + "text": " If the pNext chain includes VkRenderPassTransformBeginInfoQCOM, renderArea.extent transformed by VkRenderPassTransformBeginInfoQCOM::transform must equal the framebuffer dimensions" + } + ] + }, + "VkRenderPassSampleLocationsBeginInfoEXT": { + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-VkRenderPassSampleLocationsBeginInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT" + }, + { + "vuid": "VUID-VkRenderPassSampleLocationsBeginInfoEXT-pAttachmentInitialSampleLocations-parameter", + "text": " If attachmentInitialSampleLocationsCount is not 0, pAttachmentInitialSampleLocations must be a valid pointer to an array of attachmentInitialSampleLocationsCount valid VkAttachmentSampleLocationsEXT structures" + }, + { + "vuid": "VUID-VkRenderPassSampleLocationsBeginInfoEXT-pPostSubpassSampleLocations-parameter", + "text": " If postSubpassSampleLocationsCount is not 0, pPostSubpassSampleLocations must be a valid pointer to an array of postSubpassSampleLocationsCount valid VkSubpassSampleLocationsEXT structures" + } + ] + }, + "VkAttachmentSampleLocationsEXT": { + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-VkAttachmentSampleLocationsEXT-attachmentIndex-01531", + "text": " attachmentIndex must be less than the attachmentCount specified in VkRenderPassCreateInfo the render pass specified by VkRenderPassBeginInfo::renderPass was created with" + }, + { + "vuid": "VUID-VkAttachmentSampleLocationsEXT-sampleLocationsInfo-parameter", + "text": " sampleLocationsInfo must be a valid VkSampleLocationsInfoEXT structure" + } + ] + }, + "VkSubpassSampleLocationsEXT": { + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-VkSubpassSampleLocationsEXT-subpassIndex-01532", + "text": " subpassIndex must be less than the subpassCount specified in VkRenderPassCreateInfo the render pass specified by VkRenderPassBeginInfo::renderPass was created with" + }, + { + "vuid": "VUID-VkSubpassSampleLocationsEXT-sampleLocationsInfo-parameter", + "text": " sampleLocationsInfo must be a valid VkSampleLocationsInfoEXT structure" + } + ] + }, + "VkRenderPassTransformBeginInfoQCOM": { + "(VK_QCOM_render_pass_transform)": [ + { + "vuid": "VUID-VkRenderPassTransformBeginInfoQCOM-transform-02871", + "text": " transform must be VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR, VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR, or VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR" + }, + { + "vuid": "VUID-VkRenderPassTransformBeginInfoQCOM-flags-02872", + "text": " The renderpass must have been created with VkRenderPassCreateInfo::flags containing VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM" + } + ] + }, + "VkSubpassBeginInfo": { + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)": [ + { + "vuid": "VUID-VkSubpassBeginInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO" + }, + { + "vuid": "VUID-VkSubpassBeginInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkSubpassBeginInfo-contents-parameter", + "text": " contents must be a valid VkSubpassContents value" + } + ] + }, + "VkDeviceGroupRenderPassBeginInfo": { + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00905", + "text": " deviceMask must be a valid device mask value" + }, + { + "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00906", + "text": " deviceMask must not be zero" + }, + { + "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-deviceMask-00907", + "text": " deviceMask must be a subset of the command buffer’s initial device mask" + }, + { + "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-deviceRenderAreaCount-00908", + "text": " deviceRenderAreaCount must either be zero or equal to the number of physical devices in the logical device" + }, + { + "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-offset-06166", + "text": " The offset.x member of any element of pDeviceRenderAreas must be greater than or equal to 0" + }, + { + "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-offset-06167", + "text": " The offset.y member of any element of pDeviceRenderAreas must be greater than or equal to 0" + }, + { + "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-offset-06168", + "text": " The sum of the offset.x and extent.width members of any element of pDeviceRenderAreas must be less than or equal to maxFramebufferWidth" + }, + { + "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-offset-06169", + "text": " The sum of the offset.y and extent.height members of any element of pDeviceRenderAreas must be less than or equal to maxFramebufferHeight" + }, + { + "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO" + }, + { + "vuid": "VUID-VkDeviceGroupRenderPassBeginInfo-pDeviceRenderAreas-parameter", + "text": " If deviceRenderAreaCount is not 0, pDeviceRenderAreas must be a valid pointer to an array of deviceRenderAreaCount VkRect2D structures" + } + ] + }, + "VkRenderPassAttachmentBeginInfo": { + "(VK_VERSION_1_2,VK_KHR_imageless_framebuffer)": [ + { + "vuid": "VUID-VkRenderPassAttachmentBeginInfo-pAttachments-03218", + "text": " Each element of pAttachments must only specify a single mip level" + }, + { + "vuid": "VUID-VkRenderPassAttachmentBeginInfo-pAttachments-03219", + "text": " Each element of pAttachments must have been created with the identity swizzle" + }, + { + "vuid": "VUID-VkRenderPassAttachmentBeginInfo-pAttachments-04114", + "text": " Each element of pAttachments must have been created with VkImageViewCreateInfo::viewType not equal to VK_IMAGE_VIEW_TYPE_3D" + }, + { + "vuid": "VUID-VkRenderPassAttachmentBeginInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO" + }, + { + "vuid": "VUID-VkRenderPassAttachmentBeginInfo-pAttachments-parameter", + "text": " If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkImageView handles" + } + ] + }, + "vkGetRenderAreaGranularity": { + "core": [ + { + "vuid": "VUID-vkGetRenderAreaGranularity-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetRenderAreaGranularity-renderPass-parameter", + "text": " renderPass must be a valid VkRenderPass handle" + }, + { + "vuid": "VUID-vkGetRenderAreaGranularity-pGranularity-parameter", + "text": " pGranularity must be a valid pointer to a VkExtent2D structure" + }, + { + "vuid": "VUID-vkGetRenderAreaGranularity-renderPass-parent", + "text": " renderPass must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCmdNextSubpass": { + "core": [ + { + "vuid": "VUID-vkCmdNextSubpass-None-00909", + "text": " The current subpass index must be less than the number of subpasses in the render pass minus one" + }, + { + "vuid": "VUID-vkCmdNextSubpass-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdNextSubpass-contents-parameter", + "text": " contents must be a valid VkSubpassContents value" + }, + { + "vuid": "VUID-vkCmdNextSubpass-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdNextSubpass-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdNextSubpass-renderpass", + "text": " This command must only be called inside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdNextSubpass-bufferlevel", + "text": " commandBuffer must be a primary VkCommandBuffer" + } + ], + "(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdNextSubpass-None-02349", + "text": " This command must not be recorded when transform feedback is active" + } + ] + }, + "vkCmdNextSubpass2": { + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)": [ + { + "vuid": "VUID-vkCmdNextSubpass2-None-03102", + "text": " The current subpass index must be less than the number of subpasses in the render pass minus one" + }, + { + "vuid": "VUID-vkCmdNextSubpass2-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdNextSubpass2-pSubpassBeginInfo-parameter", + "text": " pSubpassBeginInfo must be a valid pointer to a valid VkSubpassBeginInfo structure" + }, + { + "vuid": "VUID-vkCmdNextSubpass2-pSubpassEndInfo-parameter", + "text": " pSubpassEndInfo must be a valid pointer to a valid VkSubpassEndInfo structure" + }, + { + "vuid": "VUID-vkCmdNextSubpass2-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdNextSubpass2-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdNextSubpass2-renderpass", + "text": " This command must only be called inside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdNextSubpass2-bufferlevel", + "text": " commandBuffer must be a primary VkCommandBuffer" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdNextSubpass2-None-02350", + "text": " This command must not be recorded when transform feedback is active" + } + ] + }, + "vkCmdEndRenderPass": { + "core": [ + { + "vuid": "VUID-vkCmdEndRenderPass-None-00910", + "text": " The current subpass index must be equal to the number of subpasses in the render pass minus one" + }, + { + "vuid": "VUID-vkCmdEndRenderPass-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdEndRenderPass-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdEndRenderPass-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdEndRenderPass-renderpass", + "text": " This command must only be called inside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdEndRenderPass-bufferlevel", + "text": " commandBuffer must be a primary VkCommandBuffer" + } + ], + "(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdEndRenderPass-None-02351", + "text": " This command must not be recorded when transform feedback is active" + } + ], + "(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdEndRenderPass-None-06170", + "text": " The current render pass instance must not have been begun with vkCmdBeginRenderingKHR" + } + ] + }, + "vkCmdEndRenderPass2": { + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)": [ + { + "vuid": "VUID-vkCmdEndRenderPass2-None-03103", + "text": " The current subpass index must be equal to the number of subpasses in the render pass minus one" + }, + { + "vuid": "VUID-vkCmdEndRenderPass2-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdEndRenderPass2-pSubpassEndInfo-parameter", + "text": " pSubpassEndInfo must be a valid pointer to a valid VkSubpassEndInfo structure" + }, + { + "vuid": "VUID-vkCmdEndRenderPass2-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdEndRenderPass2-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdEndRenderPass2-renderpass", + "text": " This command must only be called inside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdEndRenderPass2-bufferlevel", + "text": " commandBuffer must be a primary VkCommandBuffer" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdEndRenderPass2-None-02352", + "text": " This command must not be recorded when transform feedback is active" + } + ], + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)+(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdEndRenderPass2-None-06171", + "text": " The current render pass instance must not have been begun with vkCmdBeginRenderingKHR" + } + ] + }, + "VkSubpassEndInfo": { + "(VK_VERSION_1_2,VK_KHR_create_renderpass2)": [ + { + "vuid": "VUID-VkSubpassEndInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SUBPASS_END_INFO" + }, + { + "vuid": "VUID-VkSubpassEndInfo-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "VkShaderModuleCreateInfo": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkShaderModuleCreateInfo-codeSize-01085", + "text": " codeSize must be greater than 0" + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01089", + "text": " pCode must declare the Shader capability for SPIR-V code" + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01090", + "text": " pCode must not declare any capability that is not supported by the API, as described by the Capabilities section of the SPIR-V Environment appendix" + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01091", + "text": " If pCode declares any of the capabilities listed in the SPIR-V Environment appendix, one of the corresponding requirements must be satisfied" + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-pCode-04146", + "text": " pCode must not declare any SPIR-V extension that is not supported by the API, as described by the Extension section of the SPIR-V Environment appendix" + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-pCode-04147", + "text": " If pCode declares any of the SPIR-V extensions listed in the SPIR-V Environment appendix, one of the corresponding requirements must be satisfied" + } + ], + "!(VKSC_VERSION_1_0)+!(VK_NV_glsl_shader)": [ + { + "vuid": "VUID-VkShaderModuleCreateInfo-codeSize-01086", + "text": " codeSize must be a multiple of 4" + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01087", + "text": " pCode must point to valid SPIR-V code, formatted and packed as described by the Khronos SPIR-V Specification" + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01088", + "text": " pCode must adhere to the validation rules described by the Validation Rules within a Module section of the SPIR-V Environment appendix" + } + ], + "!(VKSC_VERSION_1_0)+(VK_NV_glsl_shader)": [ + { + "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01376", + "text": " If pCode is a pointer to SPIR-V code, codeSize must be a multiple of 4" + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01377", + "text": " pCode must point to either valid SPIR-V code, formatted and packed as described by the Khronos SPIR-V Specification or valid GLSL code which must be written to the GL_KHR_vulkan_glsl extension specification" + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01378", + "text": " If pCode is a pointer to SPIR-V code, that code must adhere to the validation rules described by the Validation Rules within a Module section of the SPIR-V Environment appendix" + }, + { + "vuid": "VUID-VkShaderModuleCreateInfo-pCode-01379", + "text": " If pCode is a pointer to GLSL code, it must be valid GLSL code written to the GL_KHR_vulkan_glsl GLSL extension specification" + } + ] + }, + "vkDestroyShaderModule": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyShaderModule-shaderModule-01092", + "text": " If VkAllocationCallbacks were provided when shaderModule was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyShaderModule-shaderModule-01093", + "text": " If no VkAllocationCallbacks were provided when shaderModule was created, pAllocator must be NULL" + } + ] + }, + "vkCmdSetPatchControlPointsEXT": { + "(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdSetPatchControlPointsEXT-None-04873", + "text": " The extendedDynamicState2PatchControlPoints feature must be enabled" + }, + { + "vuid": "VUID-vkCmdSetPatchControlPointsEXT-patchControlPoints-04874", + "text": " patchControlPoints must be greater than zero and less than or equal to VkPhysicalDeviceLimits::maxTessellationPatchSize" + }, + { + "vuid": "VUID-vkCmdSetPatchControlPointsEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetPatchControlPointsEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetPatchControlPointsEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "VkValidationCacheCreateInfoEXT": { + "(VK_EXT_validation_cache)": [ + { + "vuid": "VUID-VkValidationCacheCreateInfoEXT-initialDataSize-01534", + "text": " If initialDataSize is not 0, it must be equal to the size of pInitialData, as returned by vkGetValidationCacheDataEXT when pInitialData was originally retrieved" + }, + { + "vuid": "VUID-VkValidationCacheCreateInfoEXT-initialDataSize-01535", + "text": " If initialDataSize is not 0, pInitialData must have been retrieved from a previous call to vkGetValidationCacheDataEXT" + } + ] + }, + "vkMergeValidationCachesEXT": { + "(VK_EXT_validation_cache)": [ + { + "vuid": "VUID-vkMergeValidationCachesEXT-dstCache-01536", + "text": " dstCache must not appear in the list of source caches" + } + ] + }, + "vkDestroyValidationCacheEXT": { + "(VK_EXT_validation_cache)": [ + { + "vuid": "VUID-vkDestroyValidationCacheEXT-validationCache-01537", + "text": " If VkAllocationCallbacks were provided when validationCache was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyValidationCacheEXT-validationCache-01538", + "text": " If no VkAllocationCallbacks were provided when validationCache was created, pAllocator must be NULL" + } + ] + }, + "vkCreateComputePipelines": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateComputePipelines-flags-00695", + "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element" + }, + { + "vuid": "VUID-vkCreateComputePipelines-flags-00696", + "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateComputePipelines-pipelineCache-05022", + "text": " pipelineCache must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCreateComputePipelines-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "(VK_EXT_pipeline_creation_cache_control)": [ + { + "vuid": "VUID-vkCreateComputePipelines-pipelineCache-02873", + "text": " If pipelineCache was created with VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT, host access to pipelineCache must be externally synchronized" + } + ], + "core": [ + { + "vuid": "VUID-vkCreateComputePipelines-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateComputePipelines-pipelineCache-parameter", + "text": " pipelineCache must be a valid VkPipelineCache handle" + }, + { + "vuid": "VUID-vkCreateComputePipelines-pCreateInfos-parameter", + "text": " pCreateInfos must be a valid pointer to an array of createInfoCount valid VkComputePipelineCreateInfo structures" + }, + { + "vuid": "VUID-vkCreateComputePipelines-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateComputePipelines-pPipelines-parameter", + "text": " pPipelines must be a valid pointer to an array of createInfoCount VkPipeline handles" + }, + { + "vuid": "VUID-vkCreateComputePipelines-createInfoCount-arraylength", + "text": " createInfoCount must be greater than 0" + }, + { + "vuid": "VUID-vkCreateComputePipelines-pipelineCache-parent", + "text": " pipelineCache must have been created, allocated, or retrieved from device" + } + ] + }, + "VkComputePipelineCreateInfo": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkComputePipelineCreateInfo-flags-00697", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a compute VkPipeline" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-flags-00698", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is VK_NULL_HANDLE, basePipelineIndex must be a valid index into the calling command’s pCreateInfos parameter" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-flags-00699", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is not -1, basePipelineHandle must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-flags-00700", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is not VK_NULL_HANDLE, basePipelineIndex must be -1" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkComputePipelineCreateInfo-basePipelineHandle-05024", + "text": " basePipelineHandle must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-basePipelineIndex-05025", + "text": " basePipelineIndex must be zero" + } + ], + "core": [ + { + "vuid": "VUID-VkComputePipelineCreateInfo-stage-00701", + "text": " The stage member of stage must be VK_SHADER_STAGE_COMPUTE_BIT" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-stage-00702", + "text": " The shader code for the entry point identified by stage and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the Shader Interfaces chapter" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-layout-00703", + "text": " layout must be consistent with the layout of the compute shader specified in stage" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-layout-01687", + "text": " The number of resources in layout accessible to the compute shader stage must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkPipelineOfflineCreateInfo" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkPipelineCreateFlagBits values" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-stage-parameter", + "text": " stage must be a valid VkPipelineShaderStageCreateInfo structure" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-layout-parameter", + "text": " layout must be a valid VkPipelineLayout handle" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-commonparent", + "text": " Both of basePipelineHandle, and layout that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_KHR_pipeline_library)": [ + { + "vuid": "VUID-VkComputePipelineCreateInfo-flags-03364", + "text": " flags must not include VK_PIPELINE_CREATE_LIBRARY_BIT_KHR" + } + ], + "(VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-VkComputePipelineCreateInfo-flags-03365", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-flags-03366", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-flags-03367", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-flags-03368", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-flags-03369", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-flags-03370", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR" + }, + { + "vuid": "VUID-VkComputePipelineCreateInfo-flags-03576", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR" + } + ], + "(VK_NV_ray_tracing_motion_blur)": [ + { + "vuid": "VUID-VkComputePipelineCreateInfo-flags-04945", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV" + } + ], + "(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-VkComputePipelineCreateInfo-flags-02874", + "text": " flags must not include VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV" + } + ], + "(VK_EXT_pipeline_creation_cache_control)": [ + { + "vuid": "VUID-VkComputePipelineCreateInfo-pipelineCreationCacheControl-02875", + "text": " If the pipelineCreationCacheControl feature is not enabled, flags must not include VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT or VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT" + } + ] + }, + "VkPipelineShaderStageCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00704", + "text": " If the geometry shaders feature is not enabled, stage must not be VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00705", + "text": " If the tessellation shaders feature is not enabled, stage must not be VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT or VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00706", + "text": " stage must not be VK_SHADER_STAGE_ALL_GRAPHICS, or VK_SHADER_STAGE_ALL" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-maxClipDistances-00708", + "text": " If the identified entry point includes any variable in its interface that is declared with the ClipDistance BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxClipDistances" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-maxCullDistances-00709", + "text": " If the identified entry point includes any variable in its interface that is declared with the CullDistance BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxCullDistances" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-maxCombinedClipAndCullDistances-00710", + "text": " If the identified entry point includes any variables in its interface that are declared with the ClipDistance or CullDistance BuiltIn decoration, those variables must not have array sizes which sum to more than VkPhysicalDeviceLimits::maxCombinedClipAndCullDistances" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-maxSampleMaskWords-00711", + "text": " If the identified entry point includes any variable in its interface that is declared with the SampleMask BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxSampleMaskWords" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00712", + "text": " If stage is VK_SHADER_STAGE_VERTEX_BIT, the identified entry point must not include any input variable in its interface that is decorated with CullDistance" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00713", + "text": " If stage is VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT or VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, and the identified entry point has an OpExecutionMode instruction specifying a patch size with OutputVertices, the patch size must be greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxTessellationPatchSize" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00714", + "text": " If stage is VK_SHADER_STAGE_GEOMETRY_BIT, the identified entry point must have an OpExecutionMode instruction specifying a maximum output vertex count that is greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxGeometryOutputVertices" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00715", + "text": " If stage is VK_SHADER_STAGE_GEOMETRY_BIT, the identified entry point must have an OpExecutionMode instruction specifying an invocation count that is greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxGeometryShaderInvocations" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-02596", + "text": " If stage is a pre-rasterization shader stage, and the identified entry point writes to Layer for any primitive, it must write the same value to Layer for all vertices of a given primitive" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-02597", + "text": " If stage is a pre-rasterization shader stage, and the identified entry point writes to ViewportIndex for any primitive, it must write the same value to ViewportIndex for all vertices of a given primitive" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00718", + "text": " If stage is VK_SHADER_STAGE_FRAGMENT_BIT, the identified entry point must not include any output variables in its interface decorated with CullDistance" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-00719", + "text": " If stage is VK_SHADER_STAGE_FRAGMENT_BIT, and the identified entry point writes to FragDepth in any execution path, it must write to FragDepth in all execution paths" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-module-04145", + "text": " The SPIR-V code that was used to create module must be valid as described by the Khronos SPIR-V Specification after applying the specializations provided in pSpecializationInfo, if any, and then converting all specialization constants into fixed constants" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkPipelineShaderStageCreateFlagBits values" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-parameter", + "text": " stage must be a valid VkShaderStageFlagBits value" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-module-parameter", + "text": " If module is not VK_NULL_HANDLE, module must be a valid VkShaderModule handle" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-pName-parameter", + "text": " If pName is not NULL, pName must be a null-terminated UTF-8 string" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-pSpecializationInfo-parameter", + "text": " If pSpecializationInfo is not NULL, pSpecializationInfo must be a valid pointer to a valid VkSpecializationInfo structure" + } + ], + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-02091", + "text": " If the mesh shader feature is not enabled, stage must not be VK_SHADER_STAGE_MESH_BIT_NV" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-02092", + "text": " If the task shader feature is not enabled, stage must not be VK_SHADER_STAGE_TASK_BIT_NV" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-02093", + "text": " If stage is VK_SHADER_STAGE_MESH_BIT_NV, the identified entry point must have an OpExecutionMode instruction specifying a maximum output vertex count, OutputVertices, that is greater than 0 and less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxMeshOutputVertices" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-02094", + "text": " If stage is VK_SHADER_STAGE_MESH_BIT_NV, the identified entry point must have an OpExecutionMode instruction specifying a maximum output primitive count, OutputPrimitivesNV, that is greater than 0 and less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxMeshOutputPrimitives" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-module-05026", + "text": " module must be VK_NULL_HANDLE." + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-pName-05027", + "text": " If pName is not NULL, it must be the name of an OpEntryPoint in the SPIR-V shader module used for offline compilation of this pipeline with an execution model that matches stage" + } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-pName-00707", + "text": " pName must be the name of an OpEntryPoint in module with an execution model that matches stage" + } + ], + "(VK_EXT_shader_stencil_export)": [ + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-stage-01511", + "text": " If stage is VK_SHADER_STAGE_FRAGMENT_BIT, and the identified entry point writes to FragStencilRefEXT in any execution path, it must write to FragStencilRefEXT in all execution paths" + } + ], + "(VK_EXT_subgroup_size_control)": [ + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-flags-02784", + "text": " If flags has the VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT flag set, the subgroupSizeControl feature must be enabled" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-flags-02785", + "text": " If flags has the VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT flag set, the computeFullSubgroups feature must be enabled" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-pNext-02754", + "text": " If a VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT structure is included in the pNext chain, flags must not have the VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT flag set" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-pNext-02755", + "text": " If a VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT structure is included in the pNext chain, the subgroupSizeControl feature must be enabled, and stage must be a valid bit specified in requiredSubgroupSizeStages" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-pNext-02756", + "text": " If a VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT structure is included in the pNext chain and stage is VK_SHADER_STAGE_COMPUTE_BIT, the local workgroup size of the shader must be less than or equal to the product of VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::requiredSubgroupSize and maxComputeWorkgroupSubgroups" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-pNext-02757", + "text": " If a VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT structure is included in the pNext chain, and flags has the VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT flag set, the local workgroup size in the X dimension of the pipeline must be a multiple of VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::requiredSubgroupSize" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-flags-02758", + "text": " If flags has both the VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT and VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT flags set, the local workgroup size in the X dimension of the pipeline must be a multiple of maxSubgroupSize" + }, + { + "vuid": "VUID-VkPipelineShaderStageCreateInfo-flags-02759", + "text": " If flags has the VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT flag set and flags does not have the VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT flag set and no VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT structure is included in the pNext chain, the local workgroup size in the X dimension of the pipeline must be a multiple of subgroupSize" + } + ] + }, + "VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT": { + "(VK_EXT_subgroup_size_control)": [ + { + "vuid": "VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-requiredSubgroupSize-02760", + "text": " requiredSubgroupSize must be a power-of-two integer" + }, + { + "vuid": "VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-requiredSubgroupSize-02761", + "text": " requiredSubgroupSize must be greater or equal to minSubgroupSize" + }, + { + "vuid": "VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-requiredSubgroupSize-02762", + "text": " requiredSubgroupSize must be less than or equal to maxSubgroupSize" + }, + { + "vuid": "VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT" + } + ] + }, + "VkSubpassShadingPipelineCreateInfoHUAWEI": { + "(VK_HUAWEI_subpass_shading)": [ + { + "vuid": "VUID-VkSubpassShadingPipelineCreateInfoHUAWEI-subpass-04946", + "text": " subpass must be created with VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI bind point" + } + ] + }, + "vkCreateGraphicsPipelines": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateGraphicsPipelines-flags-00720", + "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element" + }, + { + "vuid": "VUID-vkCreateGraphicsPipelines-flags-00721", + "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateGraphicsPipelines-pipelineCache-05031", + "text": " pipelineCache must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCreateGraphicsPipelines-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "(VK_EXT_pipeline_creation_cache_control)": [ + { + "vuid": "VUID-vkCreateGraphicsPipelines-pipelineCache-02876", + "text": " If pipelineCache was created with VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT, host access to pipelineCache must be externally synchronized" + } + ], + "core": [ + { + "vuid": "VUID-vkCreateGraphicsPipelines-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateGraphicsPipelines-pipelineCache-parameter", + "text": " If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle" + }, + { + "vuid": "VUID-vkCreateGraphicsPipelines-pCreateInfos-parameter", + "text": " pCreateInfos must be a valid pointer to an array of createInfoCount valid VkGraphicsPipelineCreateInfo structures" + }, + { + "vuid": "VUID-vkCreateGraphicsPipelines-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateGraphicsPipelines-pPipelines-parameter", + "text": " pPipelines must be a valid pointer to an array of createInfoCount VkPipeline handles" + }, + { + "vuid": "VUID-vkCreateGraphicsPipelines-createInfoCount-arraylength", + "text": " createInfoCount must be greater than 0" + }, + { + "vuid": "VUID-vkCreateGraphicsPipelines-pipelineCache-parent", + "text": " If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "VkGraphicsPipelineCreateInfo": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-00722", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a graphics VkPipeline" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-00723", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is VK_NULL_HANDLE, basePipelineIndex must be a valid index into the calling command’s pCreateInfos parameter" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-00724", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is not -1, basePipelineHandle must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-00725", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is not VK_NULL_HANDLE, basePipelineIndex must be -1" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-basePipelineHandle-05033", + "text": " basePipelineHandle must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-basePipelineIndex-05034", + "text": " basePipelineIndex must be zero" + } + ], + "core": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-stage-00726", + "text": " The stage member of each element of pStages must be unique" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-stage-00728", + "text": " The stage member of each element of pStages must not be VK_SHADER_STAGE_COMPUTE_BIT" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00729", + "text": " If the pipeline is being created with pre-rasterization shader state and pStages includes a tessellation control shader stage, it must include a tessellation evaluation shader stage" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00730", + "text": " If the pipeline is being created with pre-rasterization shader state and pStages includes a tessellation evaluation shader stage, it must include a tessellation control shader stage" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00731", + "text": " If the pipeline is being created with pre-rasterization shader state and pStages includes a tessellation control shader stage and a tessellation evaluation shader stage, pTessellationState must be a valid pointer to a valid VkPipelineTessellationStateCreateInfo structure" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00732", + "text": " If the pipeline is being created with pre-rasterization shader state and pStages includes tessellation shader stages, the shader code of at least one stage must contain an OpExecutionMode instruction specifying the type of subdivision in the pipeline" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00733", + "text": " If the pipeline is being created with pre-rasterization shader state and pStages includes tessellation shader stages, and the shader code of both stages contain an OpExecutionMode instruction specifying the type of subdivision in the pipeline, they must both specify the same subdivision mode" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00734", + "text": " If the pipeline is being created with pre-rasterization shader state and pStages includes tessellation shader stages, the shader code of at least one stage must contain an OpExecutionMode instruction specifying the output patch size in the pipeline" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00735", + "text": " If the pipeline is being created with pre-rasterization shader state and pStages includes tessellation shader stages, and the shader code of both contain an OpExecutionMode instruction specifying the out patch size in the pipeline, they must both specify the same patch size" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00736", + "text": " If the pipeline is being created with pre-rasterization shader state and pStages includes tessellation shader stages, the topology member of pInputAssembly must be VK_PRIMITIVE_TOPOLOGY_PATCH_LIST" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-topology-00737", + "text": " If the pipeline is being created with pre-rasterization shader state and the topology member of pInputAssembly is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, pStages must include tessellation shader stages" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00738", + "text": " If the pipeline is being created with pre-rasterization shader state and pStages includes a geometry shader stage, and does not include any tessellation shader stages, its shader code must contain an OpExecutionMode instruction specifying an input primitive type that is compatible with the primitive topology specified in pInputAssembly" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00739", + "text": " If the pipeline is being created with pre-rasterization shader state and pStages includes a geometry shader stage, and also includes tessellation shader stages, its shader code must contain an OpExecutionMode instruction specifying an input primitive type that is compatible with the primitive topology that is output by the tessellation stages" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00740", + "text": " If the pipeline is being created with pre-rasterization shader state and fragment shader state, it includes both a fragment shader and a geometry shader, and the fragment shader code reads from an input variable that is decorated with PrimitiveId, then the geometry shader code must write to a matching output variable, decorated with PrimitiveId, in all execution paths" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06038", + "text": " If renderPass is not VK_NULL_HANDLE and the pipeline is being created with fragment shader state the fragment shader must not read from any input attachment that is defined as VK_ATTACHMENT_UNUSED in subpass" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-00742", + "text": " If the pipeline is being created with pre-rasterization shader state and multiple pre-rasterization shader stages are included in pStages, the shader code for the entry points identified by those pStages and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the Shader Interfaces chapter" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-None-04889", + "text": " If the pipeline is being created with pre-rasterization shader state and fragment shader state, the fragment shader and last pre-rasterization shader stage and any relevant state must adhere to the pipeline linking rules described in the Shader Interfaces chapter" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06039", + "text": " If renderPass is not VK_NULL_HANDLE, the pipeline is being created with fragment shader state, and subpass uses a depth/stencil attachment in renderPass with a read-only layout for the depth aspect in the VkAttachmentReference defined by subpass, the depthWriteEnable member of pDepthStencilState must be VK_FALSE" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06040", + "text": " If renderPass is not VK_NULL_HANDLE, the pipeline is being created with fragment shader state, and subpass uses a depth/stencil attachment in renderPass with a read-only layout for the stencil aspect in the VkAttachmentReference defined by subpass, the failOp, passOp and depthFailOp members of each of the front and back members of pDepthStencilState must be VK_STENCIL_OP_KEEP" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06041", + "text": " If renderPass is not VK_NULL_HANDLE, and the pipeline is being created with fragment output interface state, then for each color attachment in the subpass, if the potential format features of the format of the corresponding attachment description do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the blendEnable member of the corresponding element of the pAttachments member of pColorBlendState must be VK_FALSE" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06042", + "text": " If renderPass is not VK_NULL_HANDLE, and the pipeline is being created with fragment output interface state, and the subpass uses color attachments, the attachmentCount member of pColorBlendState must be equal to the colorAttachmentCount used to create subpass" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00749", + "text": " If the pipeline is being created with pre-rasterization shader state, and the wide lines feature is not enabled, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_LINE_WIDTH, the lineWidth member of pRasterizationState must be 1.0" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00750", + "text": " If the pipeline is being created with pre-rasterization shader state, and the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, pViewportState must be a valid pointer to a valid VkPipelineViewportStateCreateInfo structure" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00751", + "text": " If the pipeline is being created with fragment shader state, pMultisampleState must be a valid pointer to a valid VkPipelineMultisampleStateCreateInfo structure" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06043", + "text": " If renderPass is not VK_NULL_HANDLE, the pipeline is being created with fragment shader state, and subpass uses a depth/stencil attachment, pDepthStencilState must be a valid pointer to a valid VkPipelineDepthStencilStateCreateInfo structure" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06044", + "text": " If renderPass is not VK_NULL_HANDLE, the pipeline is being created with fragment output interface state, and subpass uses color attachments, pColorBlendState must be a valid pointer to a valid VkPipelineColorBlendStateCreateInfo structure" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06045", + "text": " If renderPass is not VK_NULL_HANDLE and the pipeline is being created with fragment output interface state, pColorBlendState->attachmentCount must be greater than the index of all color attachments that are not VK_ATTACHMENT_UNUSED for the subpass index in renderPass" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00754", + "text": " If the pipeline is being created with pre-rasterization shader state, the depth bias clamping feature is not enabled, no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_DEPTH_BIAS, and the depthBiasEnable member of pRasterizationState is VK_TRUE, the depthBiasClamp member of pRasterizationState must be 0.0" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-layout-00756", + "text": " layout must be consistent with all shaders specified in pStages" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-00757", + "text": " If the pipeline is being created with fragment shader state, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, and if subpass uses color and/or depth/stencil attachments, then the rasterizationSamples member of pMultisampleState must be the same as the sample count for those subpass attachments" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-00758", + "text": " If the pipeline is being created with fragment shader state and subpass does not use any color and/or depth/stencil attachments, then the rasterizationSamples member of pMultisampleState must follow the rules for a zero-attachment subpass" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06046", + "text": " If renderPass is a valid renderPass, subpass must be a valid subpass within renderPass" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-layout-01688", + "text": " The number of resources in layout accessible to each shader stage that is used by the pipeline must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-02098", + "text": " If the pipeline is being created with vertex input state, pInputAssemblyState must be a valid pointer to a valid VkPipelineInputAssemblyStateCreateInfo structure" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-None-04893", + "text": " The pipeline must be created with a complete set of state" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineDiscardRectangleStateCreateInfoEXT, VkPipelineFragmentShadingRateStateCreateInfoKHR, or VkPipelineOfflineCreateInfo" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkPipelineCreateFlagBits values" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-parameter", + "text": " If stageCount is not 0, pStages must be a valid pointer to an array of stageCount valid VkPipelineShaderStageCreateInfo structures" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pRasterizationState-parameter", + "text": " pRasterizationState must be a valid pointer to a valid VkPipelineRasterizationStateCreateInfo structure" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicState-parameter", + "text": " If pDynamicState is not NULL, pDynamicState must be a valid pointer to a valid VkPipelineDynamicStateCreateInfo structure" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-layout-parameter", + "text": " layout must be a valid VkPipelineLayout handle" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-parameter", + "text": " If renderPass is not VK_NULL_HANDLE, renderPass must be a valid VkRenderPass handle" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-commonparent", + "text": " Each of basePipelineHandle, layout, and renderPass that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "!(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-stage-00727", + "text": " If the pipeline is being created with pre-rasterization shader state the stage member of one element of pStages must be VK_SHADER_STAGE_VERTEX_BIT" + } + ], + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-02095", + "text": " If the pipeline is being created with pre-rasterization shader state the geometric shader stages provided in pStages must be either from the mesh shading pipeline (stage is VK_SHADER_STAGE_TASK_BIT_NV or VK_SHADER_STAGE_MESH_BIT_NV) or from the primitive shading pipeline (stage is VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, or VK_SHADER_STAGE_GEOMETRY_BIT)" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-stage-02096", + "text": " If the pipeline is being created with pre-rasterization shader state the stage member of one element of pStages must be either VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_MESH_BIT_NV" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-PrimitiveId-06264", + "text": " If the pipeline is being created with pre-rasterization shader state, it includes a mesh shader and the fragment shader code reads from an input variable that is decorated with PrimitiveId, then the mesh shader code must write to a matching output variable, decorated with PrimitiveId, in all execution paths" + } + ], + "!(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00747", + "text": " If the pipeline is being created with pre-rasterization shader state, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_VIEWPORT, the pViewports member of pViewportState must be a valid pointer to an array of pViewportState->viewportCount valid VkViewport structures" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00748", + "text": " If the pipeline is being created with pre-rasterization shader state, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SCISSOR, the pScissors member of pViewportState must be a valid pointer to an array of pViewportState->scissorCount VkRect2D structures" + } + ], + "(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04130", + "text": " If the pipeline is being created with pre-rasterization shader state, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_VIEWPORT or VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT, the pViewports member of pViewportState must be a valid pointer to an array of pViewportState->viewportCount valid VkViewport structures" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04131", + "text": " If the pipeline is being created with pre-rasterization shader state, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SCISSOR or VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT, the pScissors member of pViewportState must be a valid pointer to an array of pViewportState->scissorCount VkRect2D structures" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-03378", + "text": " If the extendedDynamicState feature is not enabled, there must be no element of the pDynamicStates member of pDynamicState set to VK_DYNAMIC_STATE_CULL_MODE_EXT, VK_DYNAMIC_STATE_FRONT_FACE_EXT, VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT, VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT, VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT, VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT, VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT, VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT, VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT, VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT, VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT, or VK_DYNAMIC_STATE_STENCIL_OP_EXT" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-03379", + "text": " If the pipeline is being created with pre-rasterization shader state, and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT is included in the pDynamicStates array then viewportCount must be zero" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-03380", + "text": " If the pipeline is being created with pre-rasterization shader state, and VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT is included in the pDynamicStates array then scissorCount must be zero" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04132", + "text": " If the pipeline is being created with pre-rasterization shader state, and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT is included in the pDynamicStates array then VK_DYNAMIC_STATE_VIEWPORT must not be present" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04133", + "text": " If the pipeline is being created with pre-rasterization shader state, and VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT is included in the pDynamicStates array then VK_DYNAMIC_STATE_SCISSOR must not be present" + } + ], + "(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pViewportState-04892", + "text": " If the pipeline is being created with pre-rasterization shader state, and the graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT dynamic state enabled, pViewportState must be a valid pointer to a valid VkPipelineViewportStateCreateInfo structure" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04868", + "text": " If the extendedDynamicState2 feature is not enabled, there must be no element of the pDynamicStates member of pDynamicState set to VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT, VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT, or VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04869", + "text": " If the extendedDynamicState2LogicOp feature is not enabled, there must be no element of the pDynamicStates member of pDynamicState set to VK_DYNAMIC_STATE_LOGIC_OP_EXT" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04870", + "text": " If the extendedDynamicState2PatchControlPoints feature is not enabled, there must be no element of the pDynamicStates member of pDynamicState set to VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT" + } + ], + "!(VK_EXT_depth_range_unrestricted)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00755", + "text": " If the pipeline is being created with fragment shader state, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_DEPTH_BOUNDS, and the depthBoundsTestEnable member of pDepthStencilState is VK_TRUE, the minDepthBounds and maxDepthBounds members of pDepthStencilState must be between 0.0 and 1.0, inclusive" + } + ], + "(VK_EXT_depth_range_unrestricted)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-02510", + "text": " If the pipeline is being created with fragment shader state, and the VK_EXT_depth_range_unrestricted extension is not enabled and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_DEPTH_BOUNDS, and the depthBoundsTestEnable member of pDepthStencilState is VK_TRUE, the minDepthBounds and maxDepthBounds members of pDepthStencilState must be between 0.0 and 1.0, inclusive" + } + ], + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01521", + "text": " If the pipeline is being created with fragment shader state, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure included in the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationGridSize.width must evenly divide VkMultisamplePropertiesEXT::sampleLocationGridSize.width as returned by vkGetPhysicalDeviceMultisamplePropertiesEXT with a samples parameter equaling rasterizationSamples" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01522", + "text": " If the pipeline is being created with fragment shader state, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure included in the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationGridSize.height must evenly divide VkMultisamplePropertiesEXT::sampleLocationGridSize.height as returned by vkGetPhysicalDeviceMultisamplePropertiesEXT with a samples parameter equaling rasterizationSamples" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01523", + "text": " If the pipeline is being created with fragment shader state, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure included in the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-sampleLocationsEnable-01524", + "text": " If the pipeline is being created with fragment shader state, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure included in the pNext chain of pMultisampleState is VK_TRUE, the fragment shader code must not statically use the extended instruction InterpolateAtSample" + } + ], + "(VK_AMD_mixed_attachment_samples)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-01505", + "text": " If the pipeline is being created with fragment shader state, and the VK_AMD_mixed_attachment_samples extension is enabled, and if subpass uses color and/or depth/stencil attachments, then the rasterizationSamples member of pMultisampleState must equal the maximum of the sample counts of those subpass attachments" + } + ], + "(VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-01411", + "text": " If the pipeline is being created with fragment shader state, and the VK_NV_framebuffer_mixed_samples extension is enabled, and if subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled, then the rasterizationSamples member of pMultisampleState must be the same as the sample count of the depth/stencil attachment" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-subpass-01412", + "text": " If the pipeline is being created with fragment shader state, and the VK_NV_framebuffer_mixed_samples extension is enabled, and if subpass has any color attachments, then the rasterizationSamples member of pMultisampleState must be greater than or equal to the sample count for those subpass attachments" + } + ], + "(VK_NV_coverage_reduction_mode)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-coverageReductionMode-02722", + "text": " If the pipeline is being created with fragment shader state, and the VK_NV_coverage_reduction_mode extension is enabled, the coverage reduction mode specified by VkPipelineCoverageReductionStateCreateInfoNV::coverageReductionMode, the rasterizationSamples member of pMultisampleState and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06047", + "text": " If renderPass is a valid renderPass, the pipeline is being created with pre-rasterization shader state, and the renderPass has multiview enabled and subpass has more than one bit set in the view mask and multiviewTessellationShader is not enabled, then pStages must not include tessellation shaders" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06048", + "text": " If renderPass is a valid renderPass, the pipeline is being created with pre-rasterization shader state, and the renderPass has multiview enabled and subpass has more than one bit set in the view mask and multiviewGeometryShader is not enabled, then pStages must not include a geometry shader" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06049", + "text": " If renderPass is a valid renderPass, the pipeline is being created with pre-rasterization shader state, and the renderPass has multiview enabled and subpass has more than one bit set in the view mask, shaders in the pipeline must not write to the Layer built-in output" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06050", + "text": " If renderPass is a valid renderPass and the pipeline is being created with pre-rasterization shader state, and the renderPass has multiview enabled, then all shaders must not include variables decorated with the Layer built-in decoration in their interfaces" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-00764", + "text": " flags must not contain the VK_PIPELINE_CREATE_DISPATCH_BASE flag" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance2,VK_KHR_create_renderpass2)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-01565", + "text": " If the pipeline is being created with fragment shader state and an input attachment was referenced by an aspectMask at renderPass creation time, the fragment shader must only read from the aspects that were specified for that input attachment" + } + ], + "(VK_NV_clip_space_w_scaling)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01715", + "text": " If the pipeline is being created with pre-rasterization shader state, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV, and the viewportWScalingEnable member of a VkPipelineViewportWScalingStateCreateInfoNV structure, included in the pNext chain of pViewportState, is VK_TRUE, the pViewportWScalings member of the VkPipelineViewportWScalingStateCreateInfoNV must be a pointer to an array of VkPipelineViewportWScalingStateCreateInfoNV::viewportCount valid VkViewportWScalingNV structures" + } + ], + "(VK_NV_scissor_exclusive)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04056", + "text": " If the pipeline is being created with pre-rasterization shader state, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV, and if pViewportState->pNext chain includes a VkPipelineViewportExclusiveScissorStateCreateInfoNV structure, and if its exclusiveScissorCount member is not 0, then its pExclusiveScissors member must be a valid pointer to an array of exclusiveScissorCount VkRect2D structures" + } + ], + "(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04057", + "text": " If the pipeline is being created with pre-rasterization shader state, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV, and if pViewportState->pNext chain includes a VkPipelineViewportShadingRateImageStateCreateInfoNV structure, then its pShadingRatePalettes member must be a valid pointer to an array of viewportCount valid VkShadingRatePaletteNV structures" + } + ], + "(VK_EXT_discard_rectangles)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04058", + "text": " If the pipeline is being created with pre-rasterization shader state, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT, and if pNext chain includes a VkPipelineDiscardRectangleStateCreateInfoEXT structure, and if its discardRectangleCount member is not 0, then its pDiscardRectangles member must be a valid pointer to an array of discardRectangleCount VkRect2D structures" + } + ], + "!(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-02097", + "text": " If the pipeline is being created with vertex input state, pVertexInputState must be a valid pointer to a valid VkPipelineVertexInputStateCreateInfo structure" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pVertexInputState-04910", + "text": " If the pipeline is being created with vertex input state, and VK_DYNAMIC_STATE_VERTEX_INPUT_EXT is not set, pVertexInputState must be a valid pointer to a valid VkPipelineVertexInputStateCreateInfo structure" + } + ], + "(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-02317", + "text": " If the pipeline is being created with pre-rasterization shader state, the Xfb execution mode can be specified by no more than one shader stage in pStages" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-02318", + "text": " If the pipeline is being created with pre-rasterization shader state, and any shader stage in pStages specifies Xfb execution mode it must be the last pre-rasterization shader stage" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizationStream-02319", + "text": " If the pipeline is being created with pre-rasterization shader state, and a VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream value other than zero is specified, all variables in the output interface of the entry point being compiled decorated with Position, PointSize, ClipDistance, or CullDistance must be decorated with identical Stream values that match the rasterizationStream" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizationStream-02320", + "text": " If the pipeline is being created with pre-rasterization shader state, and VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream is zero, or not specified, all variables in the output interface of the entry point being compiled decorated with Position, PointSize, ClipDistance, or CullDistance must be decorated with a Stream value of zero, or must not specify the Stream decoration" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-geometryStreams-02321", + "text": " If the pipeline is being created with pre-rasterization shader state, and the last pre-rasterization shader stage is a geometry shader, and that geometry shader uses the GeometryStreams capability, then VkPhysicalDeviceTransformFeedbackFeaturesEXT::geometryStreams feature must be enabled" + } + ], + "(VK_EXT_transform_feedback)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-None-02322", + "text": " If the pipeline is being created with pre-rasterization shader state, and there are any mesh shader stages in the pipeline there must not be any shader stage in the pipeline with a Xfb execution mode" + } + ], + "(VK_EXT_line_rasterization)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-lineRasterizationMode-02766", + "text": " If the pipeline is being created with pre-rasterization shader state and at least one of fragment output interface state or fragment shader state, the lineRasterizationMode member of a VkPipelineRasterizationLineStateCreateInfoEXT structure included in the pNext chain of pRasterizationState is VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT or VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT, then the alphaToCoverageEnable, alphaToOneEnable, and sampleShadingEnable members of pMultisampleState must all be VK_FALSE" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-stippledLineEnable-02767", + "text": " If the pipeline is being created with pre-rasterization shader state, the stippledLineEnable member of VkPipelineRasterizationLineStateCreateInfoEXT is VK_TRUE, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_LINE_STIPPLE_EXT, then the lineStippleFactor member of VkPipelineRasterizationLineStateCreateInfoEXT must be in the range [1,256]" + } + ], + "(VK_KHR_pipeline_library)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-03371", + "text": " flags must not include VK_PIPELINE_CREATE_LIBRARY_BIT_KHR" + } + ], + "(VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-03372", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-03373", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-03374", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-03375", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-03376", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-03377", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-03577", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-03578", + "text": " All elements of the pDynamicStates member of pDynamicState must not be VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR" + } + ], + "(VK_NV_ray_tracing_motion_blur)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-04947", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV" + } + ], + "(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-02877", + "text": " If flags includes VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV, then the VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::deviceGeneratedCommands feature must be enabled" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-02966", + "text": " If the pipeline is being created with pre-rasterization shader state and flags includes VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV, then all stages must not specify Xfb execution mode" + } + ], + "(VK_EXT_pipeline_creation_cache_control)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pipelineCreationCacheControl-02878", + "text": " If the pipelineCreationCacheControl feature is not enabled, flags must not include VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT or VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT" + } + ], + "(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04494", + "text": " If the pipeline is being created with pre-rasterization shader state or fragment shader state and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in pDynamicState->pDynamicStates, VkPipelineFragmentShadingRateStateCreateInfoKHR::fragmentSize.width must be greater than or equal to 1" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04495", + "text": " If the pipeline is being created with pre-rasterization shader state or fragment shader state and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in pDynamicState->pDynamicStates, VkPipelineFragmentShadingRateStateCreateInfoKHR::fragmentSize.height must be greater than or equal to 1" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04496", + "text": " If the pipeline is being created with pre-rasterization shader state or fragment shader state and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in pDynamicState->pDynamicStates, VkPipelineFragmentShadingRateStateCreateInfoKHR::fragmentSize.width must be a power-of-two value" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04497", + "text": " If the pipeline is being created with pre-rasterization shader state or fragment shader state and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in pDynamicState->pDynamicStates, VkPipelineFragmentShadingRateStateCreateInfoKHR::fragmentSize.height must be a power-of-two value" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04498", + "text": " If the pipeline is being created with pre-rasterization shader state or fragment shader state and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in pDynamicState->pDynamicStates, VkPipelineFragmentShadingRateStateCreateInfoKHR::fragmentSize.width must be less than or equal to 4" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04499", + "text": " If the pipeline is being created with pre-rasterization shader state or fragment shader state and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in pDynamicState->pDynamicStates, VkPipelineFragmentShadingRateStateCreateInfoKHR::fragmentSize.height must be less than or equal to 4" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04500", + "text": " If the pipeline is being created with pre-rasterization shader state or fragment shader state and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in pDynamicState->pDynamicStates, and the pipelineFragmentShadingRate feature is not enabled, VkPipelineFragmentShadingRateStateCreateInfoKHR::fragmentSize.width and VkPipelineFragmentShadingRateStateCreateInfoKHR::fragmentSize.height must both be equal to 1" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04501", + "text": " If the pipeline is being created with pre-rasterization shader state or fragment shader state and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in pDynamicState->pDynamicStates, and the primitiveFragmentShadingRate feature is not enabled, VkPipelineFragmentShadingRateStateCreateInfoKHR::combinerOps[0] must be VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04502", + "text": " If the pipeline is being created with pre-rasterization shader state or fragment shader state and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in pDynamicState->pDynamicStates, and the attachmentFragmentShadingRate feature is not enabled, VkPipelineFragmentShadingRateStateCreateInfoKHR::combinerOps[1] must be VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-primitiveFragmentShadingRateWithMultipleViewports-04504", + "text": " If the pipeline is being created with pre-rasterization shader state and the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, and entry points specified in pStages write to the ViewportIndex built-in, they must not also write to the PrimitiveShadingRateKHR built-in" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-fragmentShadingRateNonTrivialCombinerOps-04506", + "text": " If the pipeline is being created with pre-rasterization shader state or fragment shader state, the fragmentShadingRateNonTrivialCombinerOps limit is not supported, and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in pDynamicState->pDynamicStates, elements of VkPipelineFragmentShadingRateStateCreateInfoKHR::combinerOps must be VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR or VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR" + } + ], + "(VK_KHR_fragment_shading_rate)+(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-primitiveFragmentShadingRateWithMultipleViewports-04503", + "text": " If the pipeline is being created with pre-rasterization shader state and the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT is not included in pDynamicState->pDynamicStates, and VkPipelineViewportStateCreateInfo::viewportCount is greater than 1, entry points specified in pStages must not write to the PrimitiveShadingRateKHR built-in" + } + ], + "(VK_KHR_fragment_shading_rate)+(VK_NV_viewport_array2)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-primitiveFragmentShadingRateWithMultipleViewports-04505", + "text": " If the pipeline is being created with pre-rasterization shader state and the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, and entry points specified in pStages write to the ViewportMaskNV built-in, they must not also write to the PrimitiveShadingRateKHR built-in" + } + ], + "(VK_NV_fragment_shading_rate_enums)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04569", + "text": " If the pipeline is being created with pre-rasterization shader state or fragment shader state, and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in pDynamicState->pDynamicStates, and the fragmentShadingRateEnums feature is not enabled, VkPipelineFragmentShadingRateEnumStateCreateInfoNV::shadingRateType must be equal to VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04570", + "text": " If the pipeline is being created with pre-rasterization shader state or fragment shader state, and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in pDynamicState->pDynamicStates, and the pipelineFragmentShadingRate feature is not enabled, VkPipelineFragmentShadingRateEnumStateCreateInfoNV::shadingRate must be equal to VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04571", + "text": " If the pipeline is being created with pre-rasterization shader state or fragment shader state, and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in pDynamicState->pDynamicStates, and the primitiveFragmentShadingRate feature is not enabled, VkPipelineFragmentShadingRateEnumStateCreateInfoNV::combinerOps[0] must be VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04572", + "text": " If the pipeline is being created with pre-rasterization shader state or fragment shader state, and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in pDynamicState->pDynamicStates, and the attachmentFragmentShadingRate feature is not enabled, VkPipelineFragmentShadingRateEnumStateCreateInfoNV::combinerOps[1] must be VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-fragmentShadingRateNonTrivialCombinerOps-04573", + "text": " If the pipeline is being created with pre-rasterization shader state or fragment shader state, and the fragmentShadingRateNonTrivialCombinerOps limit is not supported and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in pDynamicState->pDynamicStates, elements of VkPipelineFragmentShadingRateEnumStateCreateInfoNV::combinerOps must be VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR or VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-None-04574", + "text": " If the pipeline is being created with pre-rasterization shader state or fragment shader state, and the supersampleFragmentShadingRates feature is not enabled, VkPipelineFragmentShadingRateEnumStateCreateInfoNV::shadingRate must not be equal to VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV, VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV, VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV, or VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-None-04575", + "text": " If the pipeline is being created with pre-rasterization shader state or fragment shader state, and the noInvocationFragmentShadingRates feature is not enabled, VkPipelineFragmentShadingRateEnumStateCreateInfoNV::shadingRate must not be equal to VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV" + } + ], + "(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04807", + "text": " If the pipeline is being created with pre-rasterization shader state and the vertexInputDynamicState feature is not enabled, there must be no element of the pDynamicStates member of pDynamicState set to VK_DYNAMIC_STATE_VERTEX_INPUT_EXT" + } + ], + "(VK_EXT_color_write_enable)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04800", + "text": " If the colorWriteEnable feature is not enabled, there must be no element of the pDynamicStates member of pDynamicState set to VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT" + } + ], + "(VK_QCOM_render_pass_shader_resolve)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizationSamples-04899", + "text": " If the pipeline is being created with fragment shader state, and the VK_QCOM_render_pass_shader_resolve extension is enabled, and if subpass has any input attachments, and if the subpass description contains VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM, then the sample count of the input attachments must equal rasterizationSamples" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-sampleShadingEnable-04900", + "text": " If the pipeline is being created with fragment shader state, and the VK_QCOM_render_pass_shader_resolve extension is enabled, and if the subpass description contains VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM, then sampleShadingEnable must be false" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-04901", + "text": " If flags includes VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM, then the subpass must be the last subpass in a subpass dependency chain" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-04902", + "text": " If flags includes VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM, and if pResolveAttachments is not NULL, then each resolve attachment must be VK_ATTACHMENT_UNUSED" + } + ], + "!(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06051", + "text": " renderPass must not be VK_NULL_HANDLE" + } + ], + "(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-dynamicRendering-06052", + "text": " If the dynamicRendering feature is not enabled, renderPass must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06053", + "text": " If renderPass is VK_NULL_HANDLE, the pipeline is being created with fragment shader state, and either of VkPipelineRenderingCreateInfoKHR::depthAttachmentFormat or VkPipelineRenderingCreateInfoKHR::stencilAttachmentFormat are not VK_FORMAT_UNDEFINED, pDepthStencilState must be a valid pointer to a valid VkPipelineDepthStencilStateCreateInfo structure" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06054", + "text": " If renderPass is VK_NULL_HANDLE, the pipeline is being created with fragment output interface state, and VkPipelineRenderingCreateInfoKHR::colorAttachmentCount is not equal to 0, pColorBlendState must be a valid pointer to a valid VkPipelineColorBlendStateCreateInfo structure" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06055", + "text": " If renderPass is VK_NULL_HANDLE and the pipeline is being created with fragment output interface state, pColorBlendState->attachmentCount must be equal to VkPipelineRenderingCreateInfoKHR::colorAttachmentCount" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06056", + "text": " If renderPass is VK_NULL_HANDLE and the pipeline is being created with fragment shader state the fragment shader must not read from any input attachment" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_KHR_multiview,VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06057", + "text": " If renderPass is VK_NULL_HANDLE, the pipeline is being created with pre-rasterization shader state, the viewMask member of a VkPipelineRenderingCreateInfoKHR structure included in the pNext chain is not 0, and the multiviewTessellationShader feature is not enabled, then pStages must not include tessellation shaders" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06058", + "text": " If renderPass is VK_NULL_HANDLE, the pipeline is being created with pre-rasterization shader state, the viewMask member of a VkPipelineRenderingCreateInfoKHR structure included in the pNext chain is not 0, and the multiviewGeometryShader feature is not enabled, then pStages must not include a geometry shader" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06059", + "text": " If renderPass is VK_NULL_HANDLE, the pipeline is being created with pre-rasterization shader state, and the viewMask member of a VkPipelineRenderingCreateInfoKHR structure included in the pNext chain is not 0, shaders in pStages must not include variables decorated with the Layer built-in decoration in their interfaces" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06060", + "text": " If the pipeline is being created with fragment output interface state and renderPass is VK_NULL_HANDLE, pColorBlendState->attachmentCount must be equal to the colorAttachmentCount member of the VkPipelineRenderingCreateInfoKHR structure included in the pNext chain" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06061", + "text": " If the pipeline is being created with fragment shader state and renderPass is VK_NULL_HANDLE, fragment shaders in pStages must not include the InputAttachment capability" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06062", + "text": " If the pipeline is being created with fragment output interface state and renderPass is VK_NULL_HANDLE, for each color attachment format defined by the pColorAttachmentFormats member of VkPipelineRenderingCreateInfoKHR, if its potential format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the blendEnable member of the corresponding element of the pAttachments member of pColorBlendState must be VK_FALSE" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_AMD_mixed_attachment_samples,VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06063", + "text": " If the pipeline is being created with fragment output interface state and renderPass is VK_NULL_HANDLE, if the pNext chain includes VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV, the colorAttachmentCount member of that structure must be equal to the value of VkPipelineRenderingCreateInfoKHR::colorAttachmentCount" + } + ], + "(VK_ARM_rasterization_order_attachment_access)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-06466", + "text": " If pStages includes a fragment shader stage, and the fragment shader code enables early fragment tests, the flags member of VkPipelineDepthStencilStateCreateInfo must not include VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM or VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-06484", + "text": " If the pipeline is being created with fragment output interface state and the flags member of VkPipelineColorBlendStateCreateInfo includes VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM subpass must have been created with VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-06485", + "text": " If the pipeline is being created with fragment output interface state and the flags member of VkPipelineDepthStencilStateCreateInfo includes VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM, subpass must have been created with VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-06486", + "text": " If the pipeline is being created with fragment output interface state and the flags member of VkPipelineDepthStencilStateCreateInfo includes VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM, subpass must have been created with VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM" + } + ], + "(VK_ARM_rasterization_order_attachment_access)+(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-06482", + "text": " If the pipeline is being created with fragment output interface state and the flags member of VkPipelineColorBlendStateCreateInfo includes VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM, renderpass must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-06483", + "text": " If the pipeline is being created with fragment output interface state and the flags member of VkPipelineDepthStencilStateCreateInfo includes VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM or VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM, renderpass must not be VK_NULL_HANDLE" + } + ] + }, + "VkPipelineRenderingCreateInfoKHR": { + "(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-VkPipelineRenderingCreateInfoKHR-pColorAttachmentFormats-06064", + "text": " If any element of pColorAttachmentFormats is not VK_FORMAT_UNDEFINED, it must be a format with potential format features that include VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkPipelineRenderingCreateInfoKHR-depthAttachmentFormat-06065", + "text": " If depthAttachmentFormat is not VK_FORMAT_UNDEFINED, it must be a format with potential format features that include VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkPipelineRenderingCreateInfoKHR-stencilAttachmentFormat-06164", + "text": " If stencilAttachmentFormat is not VK_FORMAT_UNDEFINED, it must be a format with potential format features that include VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkPipelineRenderingCreateInfoKHR-depthAttachmentFormat-06165", + "text": " If depthAttachmentFormat is not VK_FORMAT_UNDEFINED and stencilAttachmentFormat is not VK_FORMAT_UNDEFINED, depthAttachmentFormat must equal stencilAttachmentFormat" + }, + { + "vuid": "VUID-VkPipelineRenderingCreateInfoKHR-multiview-06066", + "text": " If the multiview feature is not enabled, viewMask must be 0" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkPipelineRenderingCreateInfoKHR-viewMask-06067", + "text": " The index of the most significant bit in viewMask must be less than maxMultiviewViewCount" + } + ] + }, + "VkPipelineDynamicStateCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-01442", + "text": " Each element of pDynamicStates must be unique" + }, + { + "vuid": "VUID-VkPipelineDynamicStateCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineDynamicStateCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkPipelineDynamicStateCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-parameter", + "text": " If dynamicStateCount is not 0, pDynamicStates must be a valid pointer to an array of dynamicStateCount valid VkDynamicState values" + } + ] + }, + "VkGraphicsPipelineShaderGroupsCreateInfoNV": { + "(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-groupCount-02879", + "text": " groupCount must be at least 1 and as maximum VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::maxGraphicsShaderGroupCount" + }, + { + "vuid": "VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-groupCount-02880", + "text": " The sum of groupCount including those groups added from referenced pPipelines must also be as maximum VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::maxGraphicsShaderGroupCount" + }, + { + "vuid": "VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-pGroups-02881", + "text": " The state of the first element of pGroups must match its equivalent within the parent’s VkGraphicsPipelineCreateInfo" + }, + { + "vuid": "VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-pGroups-02882", + "text": " Each element of pGroups must in combination with the rest of the pipeline state yield a valid state configuration" + }, + { + "vuid": "VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-pPipelines-02886", + "text": " Each element of pPipelines must have been created with identical state to the pipeline currently created except the state that can be overridden by VkGraphicsShaderGroupCreateInfoNV" + }, + { + "vuid": "VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-deviceGeneratedCommands-02887", + "text": " The VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::deviceGeneratedCommands feature must be enabled" + } + ], + "(VK_NV_device_generated_commands)+!(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-pGroups-02883", + "text": " All elements of pGroups must use the same shader stage combinations" + } + ], + "(VK_NV_device_generated_commands)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-pGroups-02884", + "text": " All elements of pGroups must use the same shader stage combinations unless any mesh shader stage is used, then either combination of task and mesh or just mesh shader is valid" + }, + { + "vuid": "VUID-VkGraphicsPipelineShaderGroupsCreateInfoNV-pGroups-02885", + "text": " Mesh and regular primitive shading stages cannot be mixed across pGroups" + } + ] + }, + "VkGraphicsShaderGroupCreateInfoNV": { + "(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-VkGraphicsShaderGroupCreateInfoNV-stageCount-02888", + "text": " For stageCount, the same restrictions as in VkGraphicsPipelineCreateInfo::stageCount apply" + }, + { + "vuid": "VUID-VkGraphicsShaderGroupCreateInfoNV-pStages-02889", + "text": " For pStages, the same restrictions as in VkGraphicsPipelineCreateInfo::pStages apply" + }, + { + "vuid": "VUID-VkGraphicsShaderGroupCreateInfoNV-pVertexInputState-02890", + "text": " For pVertexInputState, the same restrictions as in VkGraphicsPipelineCreateInfo::pVertexInputState apply" + }, + { + "vuid": "VUID-VkGraphicsShaderGroupCreateInfoNV-pTessellationState-02891", + "text": " For pTessellationState, the same restrictions as in VkGraphicsPipelineCreateInfo::pTessellationState apply" + } + ] + }, + "vkCreateRayTracingPipelinesNV": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateRayTracingPipelinesNV-flags-03415", + "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element" + }, + { + "vuid": "VUID-vkCreateRayTracingPipelinesNV-flags-03416", + "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkCreateRayTracingPipelinesNV-flags-03816", + "text": " flags must not contain the VK_PIPELINE_CREATE_DISPATCH_BASE flag" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_EXT_pipeline_creation_cache_control)": [ + { + "vuid": "VUID-vkCreateRayTracingPipelinesNV-pipelineCache-02903", + "text": " If pipelineCache was created with VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT, host access to pipelineCache must be externally synchronized" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateRayTracingPipelinesNV-pipelineCache-05035", + "text": " pipelineCache must not be VK_NULL_HANDLE" + } + ] + }, + "vkCreateRayTracingPipelinesKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateRayTracingPipelinesKHR-flags-03415", + "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element" + }, + { + "vuid": "VUID-vkCreateRayTracingPipelinesKHR-flags-03416", + "text": " If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkCreateRayTracingPipelinesKHR-flags-03816", + "text": " flags must not contain the VK_PIPELINE_CREATE_DISPATCH_BASE flag" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_EXT_pipeline_creation_cache_control)": [ + { + "vuid": "VUID-vkCreateRayTracingPipelinesKHR-pipelineCache-02903", + "text": " If pipelineCache was created with VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT, host access to pipelineCache must be externally synchronized" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-vkCreateRayTracingPipelinesKHR-deferredOperation-03677", + "text": " If deferredOperation is not VK_NULL_HANDLE, it must be a valid VkDeferredOperationKHR object" + }, + { + "vuid": "VUID-vkCreateRayTracingPipelinesKHR-deferredOperation-03678", + "text": " Any previous deferred operation that was associated with deferredOperation must be complete" + }, + { + "vuid": "VUID-vkCreateRayTracingPipelinesKHR-rayTracingPipeline-03586", + "text": " The rayTracingPipeline feature must be enabled" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateRayTracingPipelinesKHR-pipelineCache-05036", + "text": " pipelineCache must not be VK_NULL_HANDLE" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_EXT_pipeline_creation_cache_control+VK_KHR_deferred_host_operations)": [ + { + "vuid": "VUID-vkCreateRayTracingPipelinesKHR-deferredOperation-03587", + "text": " If deferredOperation is not VK_NULL_HANDLE, the flags member of elements of pCreateInfos must not include VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT" + } + ] + }, + "VkRayTracingPipelineCreateInfoNV": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-03421", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a ray tracing VkPipeline" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-03422", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is VK_NULL_HANDLE, basePipelineIndex must be a valid index into the calling command’s pCreateInfos parameter" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-03423", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is not -1, basePipelineHandle must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-03424", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is not VK_NULL_HANDLE, basePipelineIndex must be -1" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-pStages-03426", + "text": " The shader code for the entry points identified by pStages, and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the Shader Interfaces chapter" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-layout-03427", + "text": " layout must be consistent with all shaders specified in pStages" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-layout-03428", + "text": " The number of resources in layout accessible to each shader stage that is used by the pipeline must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-stage-06232", + "text": " The stage member of at least one element of pStages must be VK_SHADER_STAGE_RAYGEN_BIT_KHR" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-maxRecursionDepth-03457", + "text": " maxRecursionDepth must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxRecursionDepth" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-02904", + "text": " flags must not include VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_EXT_pipeline_creation_cache_control)": [ + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-pipelineCreationCacheControl-02905", + "text": " If the pipelineCreationCacheControl feature is not enabled, flags must not include VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT or VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-02957", + "text": " flags must not include both VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV and VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT at the same time" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_KHR_pipeline_library)": [ + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-03456", + "text": " flags must not include VK_PIPELINE_CREATE_LIBRARY_BIT_KHR" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-03458", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-03459", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-03460", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-03461", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-03462", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-03463", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-03588", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_NV_ray_tracing_motion_blur)": [ + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-flags-04948", + "text": " flags must not include VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-basePipelineHandle-05038", + "text": " basePipelineHandle must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-basePipelineIndex-05039", + "text": " basePipelineIndex must be zero" + } + ] + }, + "VkRayTracingPipelineCreateInfoKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-flags-03421", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a ray tracing VkPipeline" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-flags-03422", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is VK_NULL_HANDLE, basePipelineIndex must be a valid index into the calling command’s pCreateInfos parameter" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-flags-03423", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is not -1, basePipelineHandle must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-flags-03424", + "text": " If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is not VK_NULL_HANDLE, basePipelineIndex must be -1" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-pStages-03426", + "text": " The shader code for the entry points identified by pStages, and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the Shader Interfaces chapter" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-layout-03427", + "text": " layout must be consistent with all shaders specified in pStages" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-layout-03428", + "text": " The number of resources in layout accessible to each shader stage that is used by the pipeline must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-stage-03425", + "text": " If flags does not include VK_PIPELINE_CREATE_LIBRARY_BIT_KHR, the stage member of at least one element of pStages, including those implicitly added by pLibraryInfo, must be VK_SHADER_STAGE_RAYGEN_BIT_KHR" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-maxPipelineRayRecursionDepth-03589", + "text": " maxPipelineRayRecursionDepth must be less than or equal to VkPhysicalDeviceRayTracingPipelinePropertiesKHR::maxRayRecursionDepth" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-pLibraryInfo-03595", + "text": " If the VK_KHR_pipeline_library extension is not enabled, pLibraryInfo and pLibraryInterface must be NULL" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-flags-03470", + "text": " If flags includes VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR, for any element of pGroups with a type of VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR or VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR, the anyHitShader of that element must not be VK_SHADER_UNUSED_KHR" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-flags-03471", + "text": " If flags includes VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR, for any element of pGroups with a type of VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR or VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR, the closestHitShader of that element must not be VK_SHADER_UNUSED_KHR" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-rayTraversalPrimitiveCulling-03596", + "text": " If the rayTraversalPrimitiveCulling feature is not enabled, flags must not include VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-rayTraversalPrimitiveCulling-03597", + "text": " If the rayTraversalPrimitiveCulling feature is not enabled, flags must not include VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-flags-03598", + "text": " If flags includes VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR, rayTracingPipelineShaderGroupHandleCaptureReplay must be enabled" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-rayTracingPipelineShaderGroupHandleCaptureReplay-03599", + "text": " If VkPhysicalDeviceRayTracingPipelineFeaturesKHR::rayTracingPipelineShaderGroupHandleCaptureReplay is VK_TRUE and the pShaderGroupCaptureReplayHandle member of any element of pGroups is not NULL, flags must include VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-pLibraryInfo-03600", + "text": " If pLibraryInfo is not NULL and its libraryCount is 0, stageCount must not be 0" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-pLibraryInfo-03601", + "text": " If pLibraryInfo is not NULL and its libraryCount is 0, groupCount must not be 0" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-pDynamicStates-03602", + "text": " Any element of the pDynamicStates member of pDynamicState must be VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-flags-02904", + "text": " flags must not include VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_EXT_pipeline_creation_cache_control)": [ + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-pipelineCreationCacheControl-02905", + "text": " If the pipelineCreationCacheControl feature is not enabled, flags must not include VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT or VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_pipeline_library)": [ + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-flags-03465", + "text": " If flags includes VK_PIPELINE_CREATE_LIBRARY_BIT_KHR, pLibraryInterface must not be NULL" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-pLibraryInfo-03590", + "text": " If pLibraryInfo is not NULL and its libraryCount member is greater than 0, its pLibraryInterface member must not be NULL" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-pLibraries-03591", + "text": " Each element of pLibraryInfo->pLibraries must have been created with the value of maxPipelineRayRecursionDepth equal to that in this pipeline" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-pLibraryInfo-03592", + "text": " If pLibraryInfo is not NULL, each element of its pLibraries member must have been created with a layout that is compatible with the layout in this pipeline" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-pLibraryInfo-03593", + "text": " If pLibraryInfo is not NULL, each element of its pLibraries member must have been created with values of the maxPipelineRayPayloadSize and maxPipelineRayHitAttributeSize members of pLibraryInterface equal to those in this pipeline" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-flags-03594", + "text": " If flags includes VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR, each element of pLibraryInfo->pLibraries must have been created with the VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR bit set" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-flags-04718", + "text": " If flags includes VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR, each element of pLibraryInfo->pLibraries must have been created with the VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR bit set" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-flags-04719", + "text": " If flags includes VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR, each element of pLibraryInfo->pLibraries must have been created with the VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR bit set" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-flags-04720", + "text": " If flags includes VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR, each element of pLibraryInfo->pLibraries must have been created with the VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR bit set" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-flags-04721", + "text": " If flags includes VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR, each element of pLibraryInfo->pLibraries must have been created with the VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR bit set" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-flags-04722", + "text": " If flags includes VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR, each element of pLibraryInfo->pLibraries must have been created with the VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR bit set" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-flags-04723", + "text": " If flags includes VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR, each element of pLibraryInfo->pLibraries must have been created with the VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR bit set" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-basePipelineHandle-05041", + "text": " basePipelineHandle must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-basePipelineIndex-05042", + "text": " basePipelineIndex must be zero" + } + ] + }, + "VkRayTracingShaderGroupCreateInfoNV": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoNV-type-02413", + "text": " If type is VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV then generalShader must be a valid index into VkRayTracingPipelineCreateInfoNV::pStages referring to a shader of VK_SHADER_STAGE_RAYGEN_BIT_NV, VK_SHADER_STAGE_MISS_BIT_NV, or VK_SHADER_STAGE_CALLABLE_BIT_NV" + }, + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoNV-type-02414", + "text": " If type is VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV then closestHitShader, anyHitShader, and intersectionShader must be VK_SHADER_UNUSED_NV" + }, + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoNV-type-02415", + "text": " If type is VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV then intersectionShader must be a valid index into VkRayTracingPipelineCreateInfoNV::pStages referring to a shader of VK_SHADER_STAGE_INTERSECTION_BIT_NV" + }, + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoNV-type-02416", + "text": " If type is VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV then intersectionShader must be VK_SHADER_UNUSED_NV" + }, + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoNV-closestHitShader-02417", + "text": " closestHitShader must be either VK_SHADER_UNUSED_NV or a valid index into VkRayTracingPipelineCreateInfoNV::pStages referring to a shader of VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV" + }, + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoNV-anyHitShader-02418", + "text": " anyHitShader must be either VK_SHADER_UNUSED_NV or a valid index into VkRayTracingPipelineCreateInfoNV::pStages referring to a shader of VK_SHADER_STAGE_ANY_HIT_BIT_NV" + } + ] + }, + "VkRayTracingShaderGroupCreateInfoKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoKHR-type-03474", + "text": " If type is VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR then generalShader must be a valid index into VkRayTracingPipelineCreateInfoKHR::pStages referring to a shader of VK_SHADER_STAGE_RAYGEN_BIT_KHR, VK_SHADER_STAGE_MISS_BIT_KHR, or VK_SHADER_STAGE_CALLABLE_BIT_KHR" + }, + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoKHR-type-03475", + "text": " If type is VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR then closestHitShader, anyHitShader, and intersectionShader must be VK_SHADER_UNUSED_KHR" + }, + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoKHR-type-03476", + "text": " If type is VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR then intersectionShader must be a valid index into VkRayTracingPipelineCreateInfoKHR::pStages referring to a shader of VK_SHADER_STAGE_INTERSECTION_BIT_KHR" + }, + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoKHR-type-03477", + "text": " If type is VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR then intersectionShader must be VK_SHADER_UNUSED_KHR" + }, + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoKHR-closestHitShader-03478", + "text": " closestHitShader must be either VK_SHADER_UNUSED_KHR or a valid index into VkRayTracingPipelineCreateInfoKHR::pStages referring to a shader of VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR" + }, + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoKHR-anyHitShader-03479", + "text": " anyHitShader must be either VK_SHADER_UNUSED_KHR or a valid index into VkRayTracingPipelineCreateInfoKHR::pStages referring to a shader of VK_SHADER_STAGE_ANY_HIT_BIT_KHR" + }, + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoKHR-rayTracingPipelineShaderGroupHandleCaptureReplayMixed-03603", + "text": " If VkPhysicalDeviceRayTracingPipelineFeaturesKHR::rayTracingPipelineShaderGroupHandleCaptureReplayMixed is VK_FALSE then pShaderGroupCaptureReplayHandle must not be provided if it has not been provided on a previous call to ray tracing pipeline creation" + }, + { + "vuid": "VUID-VkRayTracingShaderGroupCreateInfoKHR-rayTracingPipelineShaderGroupHandleCaptureReplayMixed-03604", + "text": " If VkPhysicalDeviceRayTracingPipelineFeaturesKHR::rayTracingPipelineShaderGroupHandleCaptureReplayMixed is VK_FALSE then the caller must guarantee that no ray tracing pipeline creation commands with pShaderGroupCaptureReplayHandle provided execute simultaneously with ray tracing pipeline creation commands without pShaderGroupCaptureReplayHandle provided" + } + ] + }, + "VkRayTracingPipelineInterfaceCreateInfoKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-VkRayTracingPipelineInterfaceCreateInfoKHR-maxPipelineRayHitAttributeSize-03605", + "text": " maxPipelineRayHitAttributeSize must be less than or equal to VkPhysicalDeviceRayTracingPipelinePropertiesKHR::maxRayHitAttributeSize" + } + ] + }, + "vkGetRayTracingShaderGroupHandlesKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-vkGetRayTracingShaderGroupHandlesKHR-pipeline-04619", + "text": " pipeline must be a ray tracing pipeline" + }, + { + "vuid": "VUID-vkGetRayTracingShaderGroupHandlesKHR-firstGroup-04050", + "text": " firstGroup must be less than the number of shader groups in pipeline" + }, + { + "vuid": "VUID-vkGetRayTracingShaderGroupHandlesKHR-firstGroup-02419", + "text": " The sum of firstGroup and groupCount must be less than or equal to the number of shader groups in pipeline" + }, + { + "vuid": "VUID-vkGetRayTracingShaderGroupHandlesKHR-dataSize-02420", + "text": " dataSize must be at least VkPhysicalDeviceRayTracingPipelinePropertiesKHR::shaderGroupHandleSize {times} groupCount" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_pipeline_library)": [ + { + "vuid": "VUID-vkGetRayTracingShaderGroupHandlesKHR-pipeline-03482", + "text": " pipeline must have not been created with VK_PIPELINE_CREATE_LIBRARY_BIT_KHR" + } + ] + }, + "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-pipeline-04620", + "text": " pipeline must be a ray tracing pipeline" + }, + { + "vuid": "VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-firstGroup-04051", + "text": " firstGroup must be less than the number of shader groups in pipeline" + }, + { + "vuid": "VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-firstGroup-03483", + "text": " The sum of firstGroup and groupCount must be less than or equal to the number of shader groups in pipeline" + }, + { + "vuid": "VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-dataSize-03484", + "text": " dataSize must be at least VkPhysicalDeviceRayTracingPipelinePropertiesKHR::shaderGroupHandleCaptureReplaySize {times} groupCount" + }, + { + "vuid": "VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-rayTracingPipelineShaderGroupHandleCaptureReplay-03606", + "text": " VkPhysicalDeviceRayTracingPipelineFeaturesKHR::rayTracingPipelineShaderGroupHandleCaptureReplay must be enabled to call this function" + }, + { + "vuid": "VUID-vkGetRayTracingCaptureReplayShaderGroupHandlesKHR-pipeline-03607", + "text": " pipeline must have been created with a flags that included VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR" + } + ] + }, + "vkCompileDeferredNV": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-vkCompileDeferredNV-pipeline-04621", + "text": " pipeline must be a ray tracing pipeline" + }, + { + "vuid": "VUID-vkCompileDeferredNV-pipeline-02237", + "text": " pipeline must have been created with VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV" + }, + { + "vuid": "VUID-vkCompileDeferredNV-shader-02238", + "text": " shader must not have been called as a deferred compile before" + } + ] + }, + "vkGetRayTracingShaderGroupStackSizeKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-vkGetRayTracingShaderGroupStackSizeKHR-pipeline-04622", + "text": " pipeline must be a ray tracing pipeline" + }, + { + "vuid": "VUID-vkGetRayTracingShaderGroupStackSizeKHR-group-03608", + "text": " The value of group must be less than the number of shader groups in pipeline" + }, + { + "vuid": "VUID-vkGetRayTracingShaderGroupStackSizeKHR-groupShader-03609", + "text": " The shader identified by groupShader in group must not be VK_SHADER_UNUSED_KHR" + } + ] + }, + "vkCmdSetRayTracingPipelineStackSizeKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-vkCmdSetRayTracingPipelineStackSizeKHR-pipelineStackSize-03610", + "text": " pipelineStackSize must be large enough for any dynamic execution through the shaders in the ray tracing pipeline used by a subsequent trace call" + } + ] + }, + "vkDestroyPipeline": { + "core": [ + { + "vuid": "VUID-vkDestroyPipeline-pipeline-00765", + "text": " All submitted commands that refer to pipeline must have completed execution" + }, + { + "vuid": "VUID-vkDestroyPipeline-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyPipeline-pipeline-parameter", + "text": " If pipeline is not VK_NULL_HANDLE, pipeline must be a valid VkPipeline handle" + }, + { + "vuid": "VUID-vkDestroyPipeline-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyPipeline-pipeline-parent", + "text": " If pipeline is a valid handle, it must have been created, allocated, or retrieved from device" + } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyPipeline-pipeline-00766", + "text": " If VkAllocationCallbacks were provided when pipeline was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyPipeline-pipeline-00767", + "text": " If no VkAllocationCallbacks were provided when pipeline was created, pAllocator must be NULL" + } + ] + }, + "vkCreatePipelineCache": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreatePipelineCache-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "core": [ + { + "vuid": "VUID-vkCreatePipelineCache-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreatePipelineCache-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkPipelineCacheCreateInfo structure" + }, + { + "vuid": "VUID-vkCreatePipelineCache-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreatePipelineCache-pPipelineCache-parameter", + "text": " pPipelineCache must be a valid pointer to a VkPipelineCache handle" + } + ] + }, + "VkPipelineCacheCreateInfo": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkPipelineCacheCreateInfo-initialDataSize-00768", + "text": " If initialDataSize is not 0, it must be equal to the size of pInitialData, as returned by vkGetPipelineCacheData when pInitialData was originally retrieved" + }, + { + "vuid": "VUID-VkPipelineCacheCreateInfo-initialDataSize-00769", + "text": " If initialDataSize is not 0, pInitialData must have been retrieved from a previous call to vkGetPipelineCacheData" + } + ], + "(VK_EXT_pipeline_creation_cache_control)": [ + { + "vuid": "VUID-VkPipelineCacheCreateInfo-pipelineCreationCacheControl-02892", + "text": " If the pipelineCreationCacheControl feature is not enabled, flags must not include VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkPipelineCacheCreateInfo-flags-05043", + "text": " flags must include VK_PIPELINE_CACHE_CREATE_READ_ONLY_BIT" + }, + { + "vuid": "VUID-VkPipelineCacheCreateInfo-flags-05044", + "text": " flags must include VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT" + }, + { + "vuid": "VUID-VkPipelineCacheCreateInfo-pInitialData-05045", + "text": " The contents of this structure and data pointed to by pInitialData must be the same as specified in one of the VkDeviceObjectReservationCreateInfo::pPipelineCacheCreateInfos structures when the device was created" + } + ], + "core": [ + { + "vuid": "VUID-VkPipelineCacheCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineCacheCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkPipelineCacheCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkPipelineCacheCreateFlagBits values" + }, + { + "vuid": "VUID-VkPipelineCacheCreateInfo-pInitialData-parameter", + "text": " pInitialData must be a valid pointer to an array of initialDataSize bytes" + }, + { + "vuid": "VUID-VkPipelineCacheCreateInfo-initialDataSize-arraylength", + "text": " initialDataSize must be greater than 0" + } + ] + }, + "vkMergePipelineCaches": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkMergePipelineCaches-dstCache-00770", + "text": " dstCache must not appear in the list of source caches" + } + ] + }, + "VkPipelineCacheHeaderVersionOne": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkPipelineCacheHeaderVersionOne-headerSize-04967", + "text": " headerSize must be 32" + }, + { + "vuid": "VUID-VkPipelineCacheHeaderVersionOne-headerVersion-04968", + "text": " headerVersion must be VK_PIPELINE_CACHE_HEADER_VERSION_ONE" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkPipelineCacheHeaderVersionOne-headerSize-05075", + "text": " headerSize must be 56" + }, + { + "vuid": "VUID-VkPipelineCacheHeaderVersionOne-headerVersion-05076", + "text": " headerVersion must be VK_PIPELINE_CACHE_HEADER_VERSION_SAFETY_CRITICAL_ONE" + } + ], + "core": [ + { + "vuid": "VUID-VkPipelineCacheHeaderVersionOne-headerVersion-parameter", + "text": " headerVersion must be a valid VkPipelineCacheHeaderVersion value" + } + ] + }, + "VkPipelineCacheHeaderVersionSafetyCriticalOne": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkPipelineCacheHeaderVersionSafetyCriticalOne-validationVersion-05077", + "text": " validationVersion must be VK_PIPELINE_CACHE_VALIDATION_VERSION_SAFETY_CRITICAL_ONE" + }, + { + "vuid": "VUID-VkPipelineCacheHeaderVersionSafetyCriticalOne-pipelineIndexStride-05078", + "text": " pipelineIndexStride must be greater than or equal to 56 (the size of the VkPipelineCacheSafetyCriticalIndexEntry structure)" + }, + { + "vuid": "VUID-VkPipelineCacheHeaderVersionSafetyCriticalOne-pipelineIndexOffset-05079", + "text": " pipelineIndexOffset + pipelineIndexCount {times} pipelineIndexStride must not exceed the size of the pipeline cache" + }, + { + "vuid": "VUID-VkPipelineCacheHeaderVersionSafetyCriticalOne-headerVersionOne-parameter", + "text": " headerVersionOne must be a valid VkPipelineCacheHeaderVersionOne structure" + }, + { + "vuid": "VUID-VkPipelineCacheHeaderVersionSafetyCriticalOne-validationVersion-parameter", + "text": " validationVersion must be a valid VkPipelineCacheValidationVersion value" + } + ] + }, + "VkPipelineCacheSafetyCriticalIndexEntry": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkPipelineCacheSafetyCriticalIndexEntry-jsonSize-05080", + "text": " if jsonSize is 0, jsonOffset must be 0" + }, + { + "vuid": "VUID-VkPipelineCacheSafetyCriticalIndexEntry-jsonSize-05081", + "text": " if jsonSize is 0, stageIndexCount must be 0" + }, + { + "vuid": "VUID-VkPipelineCacheSafetyCriticalIndexEntry-stageIndexCount-05082", + "text": " if stageIndexCount is 0, stageIndexOffset and stageIndexStride must be 0" + }, + { + "vuid": "VUID-VkPipelineCacheSafetyCriticalIndexEntry-stageIndexCount-05083", + "text": " if stageIndexCount is not 0, stageIndexStride must be greater than or equal to 16 (the size of the VkPipelineCacheStageValidationIndexEntry structure)" + }, + { + "vuid": "VUID-VkPipelineCacheSafetyCriticalIndexEntry-stageIndexCount-05084", + "text": " if stageIndexCount is not 0, stageIndexOffset + stageIndexCount {times} stageIndexStride must not exceed the size of the pipeline cache" + } + ] + }, + "VkPipelineCacheStageValidationIndexEntry": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkPipelineCacheStageValidationIndexEntry-codeSize-05085", + "text": " codeSize must be greater than 0" + }, + { + "vuid": "VUID-VkPipelineCacheStageValidationIndexEntry-codeSize-05086", + "text": " codeSize must be a multiple of 4" + }, + { + "vuid": "VUID-VkPipelineCacheStageValidationIndexEntry-codeOffset-05087", + "text": " codeOffset + codeSize must not exceed the size of the pipeline cache" + } + ] + }, + "vkDestroyPipelineCache": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyPipelineCache-pipelineCache-00771", + "text": " If VkAllocationCallbacks were provided when pipelineCache was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyPipelineCache-pipelineCache-00772", + "text": " If no VkAllocationCallbacks were provided when pipelineCache was created, pAllocator must be NULL" + } + ], + "core": [ + { + "vuid": "VUID-vkDestroyPipelineCache-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyPipelineCache-pipelineCache-parameter", + "text": " If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle" + }, + { + "vuid": "VUID-vkDestroyPipelineCache-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyPipelineCache-pipelineCache-parent", + "text": " If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "VkPipelineOfflineCreateInfo": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkPipelineOfflineCreateInfo-poolEntrySize-05028", + "text": " poolEntrySize must be one of the sizes requested via VkPipelinePoolSize when the device was created" + }, + { + "vuid": "VUID-VkPipelineOfflineCreateInfo-recyclePipelineMemory-05029", + "text": " If VkPhysicalDeviceVulkanSC10Properties::recyclePipelineMemory is VK_TRUE, the number of currently existing pipelines created with this same value of poolEntrySize plus 1 must be less than or equal to the sum of the VkPipelinePoolSize::poolEntryCount values with the same value of poolEntrySize" + }, + { + "vuid": "VUID-VkPipelineOfflineCreateInfo-recyclePipelineMemory-05030", + "text": " If VkPhysicalDeviceVulkanSC10Properties::recyclePipelineMemory is VK_FALSE, the total number of pipelines ever created with this same value of poolEntrySize plus 1 must be less than or equal to the sum of the VkPipelinePoolSize::poolEntryCount values with the same value of poolEntrySize" + }, + { + "vuid": "VUID-VkPipelineOfflineCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineOfflineCreateInfo-matchControl-parameter", + "text": " matchControl must be a valid VkPipelineMatchControl value" + } + ] + }, + "VkSpecializationInfo": { + "core": [ + { + "vuid": "VUID-VkSpecializationInfo-offset-00773", + "text": " The offset member of each element of pMapEntries must be less than dataSize" + }, + { + "vuid": "VUID-VkSpecializationInfo-pMapEntries-00774", + "text": " The size member of each element of pMapEntries must be less than or equal to dataSize minus offset" + }, + { + "vuid": "VUID-VkSpecializationInfo-constantID-04911", + "text": " The constantID value of each element of pMapEntries must be unique within pMapEntries" + }, + { + "vuid": "VUID-VkSpecializationInfo-pMapEntries-parameter", + "text": " If mapEntryCount is not 0, pMapEntries must be a valid pointer to an array of mapEntryCount valid VkSpecializationMapEntry structures" + }, + { + "vuid": "VUID-VkSpecializationInfo-pData-parameter", + "text": " If dataSize is not 0, pData must be a valid pointer to an array of dataSize bytes" + } + ] + }, + "VkSpecializationMapEntry": { + "core": [ + { + "vuid": "VUID-VkSpecializationMapEntry-constantID-00776", + "text": " For a constantID specialization constant declared in a shader, size must match the byte size of the constantID. If the specialization constant is of type boolean, size must be the byte size of VkBool32" + } + ] + }, + "VkPipelineLibraryCreateInfoKHR": { + "(VK_KHR_pipeline_library)": [ + { + "vuid": "VUID-VkPipelineLibraryCreateInfoKHR-pLibraries-03381", + "text": " Each element of pLibraries must have been created with VK_PIPELINE_CREATE_LIBRARY_BIT_KHR" + } + ] + }, + "vkCmdBindPipeline": { + "core": [ + { + "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-00777", + "text": " If pipelineBindPoint is VK_PIPELINE_BIND_POINT_COMPUTE, the VkCommandPool that commandBuffer was allocated from must support compute operations" + }, + { + "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-00778", + "text": " If pipelineBindPoint is VK_PIPELINE_BIND_POINT_GRAPHICS, the VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-00779", + "text": " If pipelineBindPoint is VK_PIPELINE_BIND_POINT_COMPUTE, pipeline must be a compute pipeline" + }, + { + "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-00780", + "text": " If pipelineBindPoint is VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline must be a graphics pipeline" + }, + { + "vuid": "VUID-vkCmdBindPipeline-pipeline-00781", + "text": " If the variable multisample rate feature is not supported, pipeline is a graphics pipeline, the current subpass uses no attachments, and this is not the first call to this function with a graphics pipeline after transitioning to the current subpass, then the sample count specified by this pipeline must match that set in the previous pipeline" + }, + { + "vuid": "VUID-vkCmdBindPipeline-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-parameter", + "text": " pipelineBindPoint must be a valid VkPipelineBindPoint value" + }, + { + "vuid": "VUID-vkCmdBindPipeline-pipeline-parameter", + "text": " pipeline must be a valid VkPipeline handle" + }, + { + "vuid": "VUID-vkCmdBindPipeline-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdBindPipeline-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdBindPipeline-commonparent", + "text": " Both of commandBuffer, and pipeline must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdBindPipeline-variableSampleLocations-01525", + "text": " If VkPhysicalDeviceSampleLocationsPropertiesEXT::variableSampleLocations is VK_FALSE, and pipeline is a graphics pipeline created with a VkPipelineSampleLocationsStateCreateInfoEXT structure having its sampleLocationsEnable member set to VK_TRUE but without VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT enabled then the current render pass instance must have been begun by specifying a VkRenderPassSampleLocationsBeginInfoEXT structure whose pPostSubpassSampleLocations member contains an element with a subpassIndex matching the current subpass index and the sampleLocationsInfo member of that element must match the sampleLocationsInfo specified in VkPipelineSampleLocationsStateCreateInfoEXT when the pipeline was created" + } + ], + "(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdBindPipeline-None-02323", + "text": " This command must not be recorded when transform feedback is active" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-02391", + "text": " If pipelineBindPoint is VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, the VkCommandPool that commandBuffer was allocated from must support compute operations" + }, + { + "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-02392", + "text": " If pipelineBindPoint is VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, pipeline must be a ray tracing pipeline" + } + ], + "(VK_KHR_pipeline_library)": [ + { + "vuid": "VUID-vkCmdBindPipeline-pipeline-03382", + "text": " pipeline must not have been created with VK_PIPELINE_CREATE_LIBRARY_BIT_KHR set" + } + ], + "(VK_NV_inherited_viewport_scissor)": [ + { + "vuid": "VUID-vkCmdBindPipeline-commandBuffer-04808", + "text": " If commandBuffer is a secondary command buffer with VkCommandBufferInheritanceViewportScissorInfoNV::viewportScissor2D enabled and pipelineBindPoint is VK_PIPELINE_BIND_POINT_GRAPHICS, then the pipeline must have been created with VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT or VK_DYNAMIC_STATE_VIEWPORT, and VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT or VK_DYNAMIC_STATE_SCISSOR enabled" + } + ], + "(VK_NV_inherited_viewport_scissor,VK_EXT_discard_rectangles)": [ + { + "vuid": "VUID-vkCmdBindPipeline-commandBuffer-04809", + "text": " If commandBuffer is a secondary command buffer with VkCommandBufferInheritanceViewportScissorInfoNV::viewportScissor2D enabled and pipelineBindPoint is VK_PIPELINE_BIND_POINT_GRAPHICS and pipeline was created with VkPipelineDiscardRectangleStateCreateInfoEXT structure and its discardRectangleCount member is not 0, then the pipeline must have been created with VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT enabled" + } + ], + "(VK_EXT_provoking_vertex)": [ + { + "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-04881", + "text": " If pipelineBindPoint is VK_PIPELINE_BIND_POINT_GRAPHICS and the provokingVertexModePerPipeline limit is VK_FALSE, then pipeline’s VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::provokingVertexMode must be the same as that of any other pipelines previously bound to this bind point within the current render pass instance, including any pipeline already bound when beginning the render pass instance" + } + ], + "(VK_HUAWEI_subpass_shading)": [ + { + "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-04949", + "text": " If pipelineBindPoint is VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI, the VkCommandPool that commandBuffer was allocated from must support compute operations" + }, + { + "vuid": "VUID-vkCmdBindPipeline-pipelineBindPoint-04950", + "text": " If pipelineBindPoint is VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI, pipeline must be a subpass shading pipeline" + } + ], + "(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdBindPipeline-pipeline-06195", + "text": " If pipeline is a graphics pipeline, this command has been called inside a render pass instance started with vkCmdBeginRenderingKHR, and commands using the previously bound graphics pipeline have been recorded within the render pass instance, then the value of VkPipelineRenderingCreateInfoKHR::colorAttachmentCount specified by this pipeline must match that set in the previous pipeline" + }, + { + "vuid": "VUID-vkCmdBindPipeline-pipeline-06196", + "text": " If pipeline is a graphics pipeline, this command has been called inside a render pass instance started with vkCmdBeginRenderingKHR, and commands using the previously bound graphics pipeline have been recorded within the render pass instance, then the elements of VkPipelineRenderingCreateInfoKHR::pColorAttachmentFormats specified by this pipeline must match that set in the previous pipeline" + }, + { + "vuid": "VUID-vkCmdBindPipeline-pipeline-06197", + "text": " If pipeline is a graphics pipeline, this command has been called inside a render pass instance started with vkCmdBeginRenderingKHR, and commands using the previously bound graphics pipeline have been recorded within the render pass instance, then the value of VkPipelineRenderingCreateInfoKHR::depthAttachmentFormat specified by this pipeline must match that set in the previous pipeline" + }, + { + "vuid": "VUID-vkCmdBindPipeline-pipeline-06194", + "text": " If pipeline is a graphics pipeline, this command has been called inside a render pass instance started with vkCmdBeginRenderingKHR, and commands using the previously bound graphics pipeline have been recorded within the render pass instance, then the value of VkPipelineRenderingCreateInfoKHR::stencilAttachmentFormat specified by this pipeline must match that set in the previous pipeline" + } + ] + }, + "vkCmdBindPipelineShaderGroupNV": { + "(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-vkCmdBindPipelineShaderGroupNV-groupIndex-02893", + "text": " groupIndex must be 0 or less than the effective VkGraphicsPipelineShaderGroupsCreateInfoNV::groupCount including the referenced pipelines" + }, + { + "vuid": "VUID-vkCmdBindPipelineShaderGroupNV-pipelineBindPoint-02894", + "text": " The pipelineBindPoint must be VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdBindPipelineShaderGroupNV-groupIndex-02895", + "text": " The same restrictions as vkCmdBindPipeline apply as if the bound pipeline was created only with the Shader Group from the groupIndex information" + }, + { + "vuid": "VUID-vkCmdBindPipelineShaderGroupNV-deviceGeneratedCommands-02896", + "text": " The VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::deviceGeneratedCommands feature must be enabled" + } + ] + }, + "vkGetPipelineExecutablePropertiesKHR": { + "(VK_KHR_pipeline_executable_properties)": [ + { + "vuid": "VUID-vkGetPipelineExecutablePropertiesKHR-pipelineExecutableInfo-03270", + "text": " pipelineExecutableInfo must be enabled" + }, + { + "vuid": "VUID-vkGetPipelineExecutablePropertiesKHR-pipeline-03271", + "text": " pipeline member of pPipelineInfo must have been created with device" + } + ] + }, + "vkGetPipelineExecutableStatisticsKHR": { + "(VK_KHR_pipeline_executable_properties)": [ + { + "vuid": "VUID-vkGetPipelineExecutableStatisticsKHR-pipelineExecutableInfo-03272", + "text": " pipelineExecutableInfo must be enabled" + }, + { + "vuid": "VUID-vkGetPipelineExecutableStatisticsKHR-pipeline-03273", + "text": " pipeline member of pExecutableInfo must have been created with device" + }, + { + "vuid": "VUID-vkGetPipelineExecutableStatisticsKHR-pipeline-03274", + "text": " pipeline member of pExecutableInfo must have been created with VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR" + } + ] + }, + "VkPipelineExecutableInfoKHR": { + "(VK_KHR_pipeline_executable_properties)": [ + { + "vuid": "VUID-VkPipelineExecutableInfoKHR-executableIndex-03275", + "text": " executableIndex must be less than the number of pipeline executables associated with pipeline as returned in the pExecutableCount parameter of vkGetPipelineExecutablePropertiesKHR" + } + ] + }, + "vkGetPipelineExecutableInternalRepresentationsKHR": { + "(VK_KHR_pipeline_executable_properties)": [ + { + "vuid": "VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipelineExecutableInfo-03276", + "text": " pipelineExecutableInfo must be enabled" + }, + { + "vuid": "VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipeline-03277", + "text": " pipeline member of pExecutableInfo must have been created with device" + }, + { + "vuid": "VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipeline-03278", + "text": " pipeline member of pExecutableInfo must have been created with VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR" + } + ] + }, + "VkPipelineCreationFeedbackCreateInfoEXT": { + "(VK_EXT_pipeline_creation_feedback)": [ + { + "vuid": "VUID-VkPipelineCreationFeedbackCreateInfoEXT-pipelineStageCreationFeedbackCount-02668", + "text": " When chained to VkGraphicsPipelineCreateInfo, VkPipelineCreationFeedbackEXT::pipelineStageCreationFeedbackCount must equal VkGraphicsPipelineCreateInfo::stageCount" + }, + { + "vuid": "VUID-VkPipelineCreationFeedbackCreateInfoEXT-pipelineStageCreationFeedbackCount-02669", + "text": " When chained to VkComputePipelineCreateInfo, VkPipelineCreationFeedbackEXT::pipelineStageCreationFeedbackCount must equal 1" + } + ], + "(VK_EXT_pipeline_creation_feedback)+(VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-VkPipelineCreationFeedbackCreateInfoEXT-pipelineStageCreationFeedbackCount-02670", + "text": " When chained to VkRayTracingPipelineCreateInfoKHR, VkPipelineCreationFeedbackEXT::pipelineStageCreationFeedbackCount must equal VkRayTracingPipelineCreateInfoKHR::stageCount" + } + ], + "(VK_EXT_pipeline_creation_feedback)+(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkPipelineCreationFeedbackCreateInfoEXT-pipelineStageCreationFeedbackCount-02969", + "text": " When chained to VkRayTracingPipelineCreateInfoNV, VkPipelineCreationFeedbackEXT::pipelineStageCreationFeedbackCount must equal VkRayTracingPipelineCreateInfoNV::stageCount" + } + ] + }, + "VkAllocationCallbacks": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkAllocationCallbacks-pfnAllocation-00632", + "text": " pfnAllocation must be a valid pointer to a valid user-defined PFN_vkAllocationFunction" + }, + { + "vuid": "VUID-VkAllocationCallbacks-pfnReallocation-00633", + "text": " pfnReallocation must be a valid pointer to a valid user-defined PFN_vkReallocationFunction" + }, + { + "vuid": "VUID-VkAllocationCallbacks-pfnFree-00634", + "text": " pfnFree must be a valid pointer to a valid user-defined PFN_vkFreeFunction" + }, + { + "vuid": "VUID-VkAllocationCallbacks-pfnInternalAllocation-00635", + "text": " If either of pfnInternalAllocation or pfnInternalFree is not NULL, both must be valid callbacks" + } + ] + }, + "vkGetPhysicalDeviceMemoryProperties": { + "core": [ + { + "vuid": "VUID-vkGetPhysicalDeviceMemoryProperties-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceMemoryProperties-pMemoryProperties-parameter", + "text": " pMemoryProperties must be a valid pointer to a VkPhysicalDeviceMemoryProperties structure" + } + ] + }, + "vkGetPhysicalDeviceMemoryProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceMemoryProperties2-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceMemoryProperties2-pMemoryProperties-parameter", + "text": " pMemoryProperties must be a valid pointer to a VkPhysicalDeviceMemoryProperties2 structure" + } + ] + }, + "VkPhysicalDeviceMemoryProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkPhysicalDeviceMemoryProperties2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2" + }, + { + "vuid": "VUID-VkPhysicalDeviceMemoryProperties2-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkPhysicalDeviceMemoryBudgetPropertiesEXT" + }, + { + "vuid": "VUID-VkPhysicalDeviceMemoryProperties2-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + } + ] + }, + "VkPhysicalDeviceMemoryBudgetPropertiesEXT": { + "(VK_EXT_memory_budget)": [ + { + "vuid": "VUID-VkPhysicalDeviceMemoryBudgetPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT" + } + ] + }, + "vkAllocateMemory": { + "core": [ + { + "vuid": "VUID-vkAllocateMemory-pAllocateInfo-01713", + "text": " pAllocateInfo->allocationSize must be less than or equal to VkPhysicalDeviceMemoryProperties::memoryHeaps[memindex].size where memindex = VkPhysicalDeviceMemoryProperties::memoryTypes[pAllocateInfo->memoryTypeIndex].heapIndex as returned by vkGetPhysicalDeviceMemoryProperties for the VkPhysicalDevice that device was created from" + }, + { + "vuid": "VUID-vkAllocateMemory-pAllocateInfo-01714", + "text": " pAllocateInfo->memoryTypeIndex must be less than VkPhysicalDeviceMemoryProperties::memoryTypeCount as returned by vkGetPhysicalDeviceMemoryProperties for the VkPhysicalDevice that device was created from" + }, + { + "vuid": "VUID-vkAllocateMemory-maxMemoryAllocationCount-04101", + "text": " There must be less than VkPhysicalDeviceLimits::maxMemoryAllocationCount device memory allocations currently allocated on the device" + }, + { + "vuid": "VUID-vkAllocateMemory-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkAllocateMemory-pAllocateInfo-parameter", + "text": " pAllocateInfo must be a valid pointer to a valid VkMemoryAllocateInfo structure" + }, + { + "vuid": "VUID-vkAllocateMemory-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkAllocateMemory-pMemory-parameter", + "text": " pMemory must be a valid pointer to a VkDeviceMemory handle" + } + ], + "(VK_AMD_device_coherent_memory)": [ + { + "vuid": "VUID-vkAllocateMemory-deviceCoherentMemory-02790", + "text": " If the deviceCoherentMemory feature is not enabled, pAllocateInfo->memoryTypeIndex must not identify a memory type supporting VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkAllocateMemory-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ] + }, + "VkMemoryAllocateInfo": { + "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-00638", + "text": " allocationSize must be greater than 0" + } + ], + "(VK_FUCHSIA_buffer_collection)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-buffer-06380", + "text": " If the parameters define an import operation from an VkBufferCollectionFUCHSIA, and VkMemoryDedicatedAllocateInfo::buffer is present and non-NULL, VkImportMemoryBufferCollectionFUCHSIA::collection and VkImportMemoryBufferCollectionFUCHSIA::index must match VkBufferCollectionBufferCreateInfoFUCHSIA::collection and VkBufferCollectionBufferCreateInfoFUCHSIA::index, respectively, of the VkBufferCollectionBufferCreateInfoFUCHSIA structure used to create the VkMemoryDedicatedAllocateInfo::buffer" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-image-06381", + "text": " If the parameters define an import operation from an VkBufferCollectionFUCHSIA, and VkMemoryDedicatedAllocateInfo::image is present and non-NULL, VkImportMemoryBufferCollectionFUCHSIA::collection and VkImportMemoryBufferCollectionFUCHSIA::index must match VkBufferCollectionImageCreateInfoFUCHSIA::collection and VkBufferCollectionImageCreateInfoFUCHSIA::index, respectively, of the VkBufferCollectionImageCreateInfoFUCHSIA structure used to create the VkMemoryDedicatedAllocateInfo::image" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-06382", + "text": " If the parameters define an import operation from an VkBufferCollectionFUCHSIA, allocationSize must match VkMemoryRequirements::size value retrieved by vkGetImageMemoryRequirements or vkGetBufferMemoryRequirements for image-based or buffer-based collections respectively" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-06383", + "text": " If the parameters define an import operation from an VkBufferCollectionFUCHSIA, the pNext chain must include a VkMemoryDedicatedAllocateInfo structure with either its image or buffer field set to a value other than VK_NULL_HANDLE." + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-image-06384", + "text": " If the parameters define an import operation from an VkBufferCollectionFUCHSIA and VkMemoryDedicatedAllocateInfo::image is not VK_NULL_HANDLE, the image must be created with a VkBufferCollectionImageCreateInfoFUCHSIA structure chained to its VkImageCreateInfo::pNext pointer" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-buffer-06385", + "text": " If the parameters define an import operation from an VkBufferCollectionFUCHSIA and VkMemoryDedicatedAllocateInfo::buffer is not VK_NULL_HANDLE, the buffer must be created with a VkBufferCollectionBufferCreateInfoFUCHSIA structure chained to its VkBufferCreateInfo::pNext pointer" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-06386", + "text": " If the parameters define an import operation from an VkBufferCollectionFUCHSIA, memoryTypeIndex must be from VkBufferCollectionPropertiesFUCHSIA as retrieved by vkGetBufferCollectionPropertiesFUCHSIA." + } + ], + "(VK_KHR_external_memory)+(VK_KHR_dedicated_allocation,VK_NV_dedicated_allocation)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-00639", + "text": " If the pNext chain includes a VkExportMemoryAllocateInfo structure, and any of the handle types specified in VkExportMemoryAllocateInfo::handleTypes require a dedicated allocation, as reported by vkGetPhysicalDeviceImageFormatProperties2 in VkExternalImageFormatProperties::externalMemoryProperties.externalMemoryFeatures or VkExternalBufferProperties::externalMemoryProperties.externalMemoryFeatures, the pNext chain must include a VkMemoryDedicatedAllocateInfo or VkDedicatedAllocationMemoryAllocateInfoNV structure with either its image or buffer member set to a value other than VK_NULL_HANDLE" + } + ], + "(VK_KHR_external_memory)+(VK_NV_external_memory)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-00640", + "text": " If the pNext chain includes a VkExportMemoryAllocateInfo structure, it must not include a VkExportMemoryAllocateInfoNV or VkExportMemoryWin32HandleInfoNV structure" + } + ], + "(VK_KHR_external_memory_win32+VK_NV_external_memory_win32)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-00641", + "text": " If the pNext chain includes a VkImportMemoryWin32HandleInfoKHR structure, it must not include a VkImportMemoryWin32HandleInfoNV structure" + } + ], + "(VK_KHR_external_memory_fd)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-01742", + "text": " If the parameters define an import operation, the external handle specified was created by the Vulkan API, and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, then the values of allocationSize and memoryTypeIndex must match those specified when the payload being imported was created" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-00648", + "text": " If the parameters define an import operation and the external handle is a POSIX file descriptor created outside of the Vulkan API, the value of memoryTypeIndex must be one of those returned by vkGetMemoryFdPropertiesKHR" + } + ], + "(VK_KHR_external_memory+VK_KHR_device_group)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-None-00643", + "text": " If the parameters define an import operation and the external handle specified was created by the Vulkan API, the device mask specified by VkMemoryAllocateFlagsInfo must match the mask specified when the payload being imported was allocated" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-None-00644", + "text": " If the parameters define an import operation and the external handle specified was created by the Vulkan API, the list of physical devices that comprise the logical device passed to vkAllocateMemory must match the list of physical devices that comprise the logical device on which the payload was originally allocated" + } + ], + "(VK_KHR_external_memory_win32)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-00645", + "text": " If the parameters define an import operation and the external handle is an NT handle or a global share handle created outside of the Vulkan API, the value of memoryTypeIndex must be one of those returned by vkGetMemoryWin32HandlePropertiesKHR" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-01743", + "text": " If the parameters define an import operation, the external handle was created by the Vulkan API, and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, then the values of allocationSize and memoryTypeIndex must match those specified when the payload being imported was created" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-00647", + "text": " If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, allocationSize must match the size specified when creating the Direct3D 12 heap from which the payload was extracted" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-01872", + "text": " If the protected memory feature is not enabled, the VkMemoryAllocateInfo::memoryTypeIndex must not indicate a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT" + } + ], + "(VK_EXT_external_memory_host)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-01744", + "text": " If the parameters define an import operation and the external handle is a host pointer, the value of memoryTypeIndex must be one of those returned by vkGetMemoryHostPointerPropertiesEXT" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-01745", + "text": " If the parameters define an import operation and the external handle is a host pointer, allocationSize must be an integer multiple of VkPhysicalDeviceExternalMemoryHostPropertiesEXT::minImportedHostPointerAlignment" + } + ], + "(VK_EXT_external_memory_host)+(VK_NV_dedicated_allocation)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-02805", + "text": " If the parameters define an import operation and the external handle is a host pointer, the pNext chain must not include a VkDedicatedAllocationMemoryAllocateInfoNV structure with either its image or buffer field set to a value other than VK_NULL_HANDLE" + } + ], + "(VK_EXT_external_memory_host)+(VK_KHR_dedicated_allocation)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-02806", + "text": " If the parameters define an import operation and the external handle is a host pointer, the pNext chain must not include a VkMemoryDedicatedAllocateInfo structure with either its image or buffer field set to a value other than VK_NULL_HANDLE" + } + ], + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-02383", + "text": " If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, allocationSize must be the size returned by vkGetAndroidHardwareBufferPropertiesANDROID for the Android hardware buffer" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-02384", + "text": " If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, and the pNext chain does not include a VkMemoryDedicatedAllocateInfo structure or VkMemoryDedicatedAllocateInfo::image is VK_NULL_HANDLE, the Android hardware buffer must have a AHardwareBuffer_Desc::format of AHARDWAREBUFFER_FORMAT_BLOB and a AHardwareBuffer_Desc::usage that includes AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-memoryTypeIndex-02385", + "text": " If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, memoryTypeIndex must be one of those returned by vkGetAndroidHardwareBufferPropertiesANDROID for the Android hardware buffer" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-01874", + "text": " If the parameters do not define an import operation, and the pNext chain includes a VkExportMemoryAllocateInfo structure with VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID included in its handleTypes member, and the pNext chain includes a VkMemoryDedicatedAllocateInfo structure with image not equal to VK_NULL_HANDLE, then allocationSize must be 0, otherwise allocationSize must be greater than 0" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-02386", + "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes a VkMemoryDedicatedAllocateInfo with image that is not VK_NULL_HANDLE, the Android hardware buffer’s AHardwareBuffer::usage must include at least one of AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER or AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-02387", + "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes a VkMemoryDedicatedAllocateInfo with image that is not VK_NULL_HANDLE, the format of image must be VK_FORMAT_UNDEFINED or the format returned by vkGetAndroidHardwareBufferPropertiesANDROID in VkAndroidHardwareBufferFormatPropertiesANDROID::format for the Android hardware buffer" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-02388", + "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes a VkMemoryDedicatedAllocateInfo structure with image that is not VK_NULL_HANDLE, the width, height, and array layer dimensions of image and the Android hardware buffer’s AHardwareBuffer_Desc must be identical" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-02389", + "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes a VkMemoryDedicatedAllocateInfo structure with image that is not VK_NULL_HANDLE, and the Android hardware buffer’s AHardwareBuffer::usage includes AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE, the image must have a complete mipmap chain" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-02586", + "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes a VkMemoryDedicatedAllocateInfo structure with image that is not VK_NULL_HANDLE, and the Android hardware buffer’s AHardwareBuffer::usage does not include AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE, the image must have exactly one mipmap level" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-02390", + "text": " If the parameters define an import operation, the external handle is an Android hardware buffer, and the pNext chain includes a VkMemoryDedicatedAllocateInfo structure with image that is not VK_NULL_HANDLE, each bit set in the usage of image must be listed in AHardwareBuffer Usage Equivalence, and if there is a corresponding AHARDWAREBUFFER_USAGE bit listed that bit must be included in the Android hardware buffer’s AHardwareBuffer_Desc::usage" + } + ], + "(VK_VERSION_1_2,VK_KHR_buffer_device_address)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-opaqueCaptureAddress-03329", + "text": " If VkMemoryOpaqueCaptureAddressAllocateInfo::opaqueCaptureAddress is not zero, VkMemoryAllocateFlagsInfo::flags must include VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-flags-03330", + "text": " If VkMemoryAllocateFlagsInfo::flags includes VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, the bufferDeviceAddressCaptureReplay feature must be enabled" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-flags-03331", + "text": " If VkMemoryAllocateFlagsInfo::flags includes VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT, the bufferDeviceAddress feature must be enabled" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-opaqueCaptureAddress-03333", + "text": " If the parameters define an import operation, VkMemoryOpaqueCaptureAddressAllocateInfo::opaqueCaptureAddress must be zero" + } + ], + "(VK_VERSION_1_2,VK_KHR_buffer_device_address)+(VK_EXT_external_memory_host)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-03332", + "text": " If the pNext chain includes a VkImportMemoryHostPointerInfoEXT structure, VkMemoryOpaqueCaptureAddressAllocateInfo::opaqueCaptureAddress must be zero" + } + ], + "(VK_FUCHSIA_external_memory)": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-None-04749", + "text": " If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA, the value of memoryTypeIndex must be an index identifying a memory type from the memoryTypeBits field of the VkMemoryZirconHandlePropertiesFUCHSIA structure populated by a call to vkGetMemoryZirconHandlePropertiesFUCHSIA" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-04750", + "text": " If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA, the value of allocationSize must be greater than 0 and must be less than or equal to the size of the VMO as determined by zx_vmo_get_size(handle) where handle is the VMO handle to the imported external memory" + } + ], + "core": [ + { + "vuid": "VUID-VkMemoryAllocateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkExportMemoryAllocateInfo, VkImportMemoryFdInfoKHR, VkImportMemoryHostPointerInfoEXT, VkMemoryAllocateFlagsInfo, VkMemoryDedicatedAllocateInfo, or VkMemoryOpaqueCaptureAddressAllocateInfo" + }, + { + "vuid": "VUID-VkMemoryAllocateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + } + ] + }, + "VkMemoryDedicatedAllocateInfo": { + "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01432", + "text": " At least one of image and buffer must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01434", + "text": " If image is not VK_NULL_HANDLE, image must have been created without VK_IMAGE_CREATE_SPARSE_BINDING_BIT set in VkImageCreateInfo::flags" + }, + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-01436", + "text": " If buffer is not VK_NULL_HANDLE, buffer must have been created without VK_BUFFER_CREATE_SPARSE_BINDING_BIT set in VkBufferCreateInfo::flags" + }, + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO" + }, + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-parameter", + "text": " If image is not VK_NULL_HANDLE, image must be a valid VkImage handle" + }, + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-parameter", + "text": " If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-commonparent", + "text": " Both of buffer, and image that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01433", + "text": " If image is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the image" + }, + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-01435", + "text": " If buffer is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the buffer" + } + ], + "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-02964", + "text": " If image is not VK_NULL_HANDLE and the memory is not an imported Android Hardware Buffer, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the image" + }, + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-02965", + "text": " If buffer is not VK_NULL_HANDLE and the memory is not an imported Android Hardware Buffer, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the buffer" + } + ], + "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_KHR_external_memory_win32)": [ + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01876", + "text": " If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, and the external handle was created by the Vulkan API, then the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory" + }, + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-01877", + "text": " If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, and the external handle was created by the Vulkan API, then the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory" + } + ], + "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_KHR_external_memory_fd)": [ + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01878", + "text": " If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory" + }, + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-01879", + "text": " If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory" + } + ], + "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-01797", + "text": " If image is not VK_NULL_HANDLE, image must not have been created with VK_IMAGE_CREATE_DISJOINT_BIT set in VkImageCreateInfo::flags" + } + ], + "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_FUCHSIA_external_memory)": [ + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-image-04751", + "text": " If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA, the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory" + }, + { + "vuid": "VUID-VkMemoryDedicatedAllocateInfo-buffer-04752", + "text": " If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation with handle type VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA, the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory" + } + ] + }, + "VkDedicatedAllocationMemoryAllocateInfoNV": { + "(VK_NV_dedicated_allocation)": [ + { + "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00649", + "text": " At least one of image and buffer must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00650", + "text": " If image is not VK_NULL_HANDLE, the image must have been created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE" + }, + { + "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00651", + "text": " If buffer is not VK_NULL_HANDLE, the buffer must have been created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE" + }, + { + "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00652", + "text": " If image is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the image" + }, + { + "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00653", + "text": " If buffer is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the buffer" + } + ], + "(VK_NV_dedicated_allocation)+(VK_KHR_external_memory_win32,VK_KHR_external_memory_fd)": [ + { + "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00654", + "text": " If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation, the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory" + }, + { + "vuid": "VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00655", + "text": " If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation, the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory" + } + ] + }, + "VkMemoryPriorityAllocateInfoEXT": { + "(VK_EXT_memory_priority)": [ + { + "vuid": "VUID-VkMemoryPriorityAllocateInfoEXT-priority-02602", + "text": " priority must be between 0 and 1, inclusive" + } + ] + }, + "vkSetDeviceMemoryPriorityEXT": { + "(VK_EXT_pageable_device_local_memory)": [ + { + "vuid": "VUID-vkSetDeviceMemoryPriorityEXT-priority-06258", + "text": " priority must be between 0 and 1, inclusive" + } + ] + }, + "VkExportMemoryAllocateInfo": { + "(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkExportMemoryAllocateInfo-handleTypes-00656", + "text": " The bits in handleTypes must be supported and compatible, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties" + }, + { + "vuid": "VUID-VkExportMemoryAllocateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO" + }, + { + "vuid": "VUID-VkExportMemoryAllocateInfo-handleTypes-parameter", + "text": " handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBits values" + } + ] + }, + "VkExportMemoryWin32HandleInfoKHR": { + "(VK_KHR_external_memory_win32)": [ + { + "vuid": "VUID-VkExportMemoryWin32HandleInfoKHR-handleTypes-00657", + "text": " If VkExportMemoryAllocateInfo::handleTypes does not include VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, a VkExportMemoryWin32HandleInfoKHR structure must not be included in the pNext chain of VkMemoryAllocateInfo" + } + ] + }, + "VkImportMemoryWin32HandleInfoKHR": { + "(VK_KHR_external_memory_win32)": [ + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00658", + "text": " If handleType is not 0, it must be supported for import, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties" + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handle-00659", + "text": " The memory from which handle was exported, or the memory named by name must have been created on the same underlying physical device as device" + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00660", + "text": " If handleType is not 0, it must be defined as an NT handle or a global share handle" + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01439", + "text": " If handleType is not VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, name must be NULL" + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01440", + "text": " If handleType is not 0 and handle is NULL, name must name a valid memory resource of the type specified by handleType" + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00661", + "text": " If handleType is not 0 and name is NULL, handle must be a valid handle of the type specified by handleType" + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handle-01441", + "text": " if handle is not NULL, name must be NULL" + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-handle-01518", + "text": " If handle is not NULL, it must obey any requirements listed for handleType in external memory handle types compatibility" + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoKHR-name-01519", + "text": " If name is not NULL, it must obey any requirements listed for handleType in external memory handle types compatibility" + } + ] + }, + "VkMemoryGetWin32HandleInfoKHR": { + "(VK_KHR_external_memory_win32)": [ + { + "vuid": "VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00662", + "text": " handleType must have been included in VkExportMemoryAllocateInfo::handleTypes when memory was created" + }, + { + "vuid": "VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00663", + "text": " If handleType is defined as an NT handle, vkGetMemoryWin32HandleKHR must be called no more than once for each valid unique combination of memory and handleType" + }, + { + "vuid": "VUID-VkMemoryGetWin32HandleInfoKHR-handleType-00664", + "text": " handleType must be defined as an NT handle or a global share handle" + } + ] + }, + "vkGetMemoryWin32HandlePropertiesKHR": { + "(VK_KHR_external_memory_win32)": [ + { + "vuid": "VUID-vkGetMemoryWin32HandlePropertiesKHR-handle-00665", + "text": " handle must be an external memory handle created outside of the Vulkan API" + }, + { + "vuid": "VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-00666", + "text": " handleType must not be one of the handle types defined as opaque" + } + ] + }, + "VkImportMemoryWin32HandleInfoNV": { + "(VK_NV_external_memory_win32)": [ + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoNV-handleType-01327", + "text": " handleType must not have more than one bit set" + }, + { + "vuid": "VUID-VkImportMemoryWin32HandleInfoNV-handle-01328", + "text": " handle must be a valid handle to memory, obtained as specified by handleType" + } + ] + }, + "vkGetMemoryWin32HandleNV": { + "(VK_NV_external_memory_win32)": [ + { + "vuid": "VUID-vkGetMemoryWin32HandleNV-handleType-01326", + "text": " handleType must be a flag specified in VkExportMemoryAllocateInfoNV::handleTypes when allocating memory" + } + ] + }, + "VkImportMemoryFdInfoKHR": { + "(VK_KHR_external_memory_fd)": [ + { + "vuid": "VUID-VkImportMemoryFdInfoKHR-handleType-00667", + "text": " If handleType is not 0, it must be supported for import, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties" + }, + { + "vuid": "VUID-VkImportMemoryFdInfoKHR-fd-00668", + "text": " The memory from which fd was exported must have been created on the same underlying physical device as device" + }, + { + "vuid": "VUID-VkImportMemoryFdInfoKHR-handleType-00669", + "text": " If handleType is not 0, it must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT" + }, + { + "vuid": "VUID-VkImportMemoryFdInfoKHR-handleType-00670", + "text": " If handleType is not 0, fd must be a valid handle of the type specified by handleType" + }, + { + "vuid": "VUID-VkImportMemoryFdInfoKHR-fd-01746", + "text": " The memory represented by fd must have been created from a physical device and driver that is compatible with device and handleType, as described in External memory handle types compatibility" + }, + { + "vuid": "VUID-VkImportMemoryFdInfoKHR-fd-01520", + "text": " fd must obey any requirements listed for handleType in external memory handle types compatibility" + }, + { + "vuid": "VUID-VkImportMemoryFdInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR" + }, + { + "vuid": "VUID-VkImportMemoryFdInfoKHR-handleType-parameter", + "text": " If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" + } + ] + }, + "vkGetMemoryFdKHR": { + "(VK_KHR_external_memory_fd)": [ + { + "vuid": "VUID-vkGetMemoryFdKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetMemoryFdKHR-pGetFdInfo-parameter", + "text": " pGetFdInfo must be a valid pointer to a valid VkMemoryGetFdInfoKHR structure" + }, + { + "vuid": "VUID-vkGetMemoryFdKHR-pFd-parameter", + "text": " pFd must be a valid pointer to an int value" + } + ] + }, + "VkMemoryGetFdInfoKHR": { + "(VK_KHR_external_memory_fd)": [ + { + "vuid": "VUID-VkMemoryGetFdInfoKHR-handleType-00671", + "text": " handleType must have been included in VkExportMemoryAllocateInfo::handleTypes when memory was created" + }, + { + "vuid": "VUID-VkMemoryGetFdInfoKHR-handleType-00672", + "text": " handleType must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT" + }, + { + "vuid": "VUID-VkMemoryGetFdInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR" + }, + { + "vuid": "VUID-VkMemoryGetFdInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkMemoryGetFdInfoKHR-memory-parameter", + "text": " memory must be a valid VkDeviceMemory handle" + }, + { + "vuid": "VUID-VkMemoryGetFdInfoKHR-handleType-parameter", + "text": " handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" + } + ] + }, + "vkGetMemoryFdPropertiesKHR": { + "(VK_KHR_external_memory_fd)": [ + { + "vuid": "VUID-vkGetMemoryFdPropertiesKHR-fd-00673", + "text": " fd must be an external memory handle created outside of the Vulkan API" + }, + { + "vuid": "VUID-vkGetMemoryFdPropertiesKHR-handleType-00674", + "text": " handleType must not be VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT" + }, + { + "vuid": "VUID-vkGetMemoryFdPropertiesKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetMemoryFdPropertiesKHR-handleType-parameter", + "text": " handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" + }, + { + "vuid": "VUID-vkGetMemoryFdPropertiesKHR-pMemoryFdProperties-parameter", + "text": " pMemoryFdProperties must be a valid pointer to a VkMemoryFdPropertiesKHR structure" + } + ] + }, + "VkMemoryFdPropertiesKHR": { + "(VK_KHR_external_memory_fd)": [ + { + "vuid": "VUID-VkMemoryFdPropertiesKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR" + }, + { + "vuid": "VUID-VkMemoryFdPropertiesKHR-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "VkImportMemoryHostPointerInfoEXT": { + "(VK_EXT_external_memory_host)": [ + { + "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-handleType-01747", + "text": " If handleType is not 0, it must be supported for import, as reported in VkExternalMemoryProperties" + }, + { + "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-handleType-01748", + "text": " If handleType is not 0, it must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT" + }, + { + "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-pHostPointer-01749", + "text": " pHostPointer must be a pointer aligned to an integer multiple of VkPhysicalDeviceExternalMemoryHostPropertiesEXT::minImportedHostPointerAlignment" + }, + { + "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-handleType-01750", + "text": " If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, pHostPointer must be a pointer to allocationSize number of bytes of host memory, where allocationSize is the member of the VkMemoryAllocateInfo structure this structure is chained to" + }, + { + "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-handleType-01751", + "text": " If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT, pHostPointer must be a pointer to allocationSize number of bytes of host mapped foreign memory, where allocationSize is the member of the VkMemoryAllocateInfo structure this structure is chained to" + }, + { + "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT" + }, + { + "vuid": "VUID-VkImportMemoryHostPointerInfoEXT-handleType-parameter", + "text": " handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" + } + ] + }, + "vkGetMemoryHostPointerPropertiesEXT": { + "(VK_EXT_external_memory_host)": [ + { + "vuid": "VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01752", + "text": " handleType must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT" + }, + { + "vuid": "VUID-vkGetMemoryHostPointerPropertiesEXT-pHostPointer-01753", + "text": " pHostPointer must be a pointer aligned to an integer multiple of VkPhysicalDeviceExternalMemoryHostPropertiesEXT::minImportedHostPointerAlignment" + }, + { + "vuid": "VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01754", + "text": " If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, pHostPointer must be a pointer to host memory" + }, + { + "vuid": "VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-01755", + "text": " If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT, pHostPointer must be a pointer to host mapped foreign memory" + }, + { + "vuid": "VUID-vkGetMemoryHostPointerPropertiesEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-parameter", + "text": " handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" + }, + { + "vuid": "VUID-vkGetMemoryHostPointerPropertiesEXT-pMemoryHostPointerProperties-parameter", + "text": " pMemoryHostPointerProperties must be a valid pointer to a VkMemoryHostPointerPropertiesEXT structure" + } + ] + }, + "VkMemoryHostPointerPropertiesEXT": { + "(VK_EXT_external_memory_host)": [ + { + "vuid": "VUID-VkMemoryHostPointerPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT" + }, + { + "vuid": "VUID-VkMemoryHostPointerPropertiesEXT-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "VkImportAndroidHardwareBufferInfoANDROID": { + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-01880", + "text": " If buffer is not NULL, Android hardware buffers must be supported for import, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties" + }, + { + "vuid": "VUID-VkImportAndroidHardwareBufferInfoANDROID-buffer-01881", + "text": " If buffer is not NULL, it must be a valid Android hardware buffer object with AHardwareBuffer_Desc::usage compatible with Vulkan as described in Android Hardware Buffers" + } + ] + }, + "VkMemoryGetAndroidHardwareBufferInfoANDROID": { + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-handleTypes-01882", + "text": " VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID must have been included in VkExportMemoryAllocateInfo::handleTypes when memory was created" + }, + { + "vuid": "VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-pNext-01883", + "text": " If the pNext chain of the VkMemoryAllocateInfo used to allocate memory included a VkMemoryDedicatedAllocateInfo with non-NULL image member, then that image must already be bound to memory" + } + ] + }, + "vkGetAndroidHardwareBufferPropertiesANDROID": { + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkGetAndroidHardwareBufferPropertiesANDROID-buffer-01884", + "text": " buffer must be a valid Android hardware buffer object with at least one of the AHARDWAREBUFFER_USAGE_GPU_* flags in its AHardwareBuffer_Desc::usage" + } + ] + }, + "VkMemoryGetRemoteAddressInfoNV": { + "(VK_NV_external_memory_rdma)": [ + { + "vuid": "VUID-VkMemoryGetRemoteAddressInfoNV-handleType-04966", + "text": " handleType must have been included in VkExportMemoryAllocateInfo::handleTypes when memory was created" + } + ] + }, + "VkImportMemoryZirconHandleInfoFUCHSIA": { + "(VK_FUCHSIA_external_memory)": [ + { + "vuid": "VUID-VkImportMemoryZirconHandleInfoFUCHSIA-handleType-04771", + "text": " handleType must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA" + }, + { + "vuid": "VUID-VkImportMemoryZirconHandleInfoFUCHSIA-handle-04772", + "text": " handle must be a valid VMO handle" + } + ] + }, + "vkGetMemoryZirconHandlePropertiesFUCHSIA": { + "(VK_FUCHSIA_external_memory)": [ + { + "vuid": "VUID-vkGetMemoryZirconHandlePropertiesFUCHSIA-handleType-04773", + "text": " handleType must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA" + }, + { + "vuid": "VUID-vkGetMemoryZirconHandlePropertiesFUCHSIA-zirconHandle-04774", + "text": " zirconHandle must reference a valid VMO" + } + ] + }, + "VkMemoryGetZirconHandleInfoFUCHSIA": { + "(VK_FUCHSIA_external_memory)": [ + { + "vuid": "VUID-VkMemoryGetZirconHandleInfoFUCHSIA-handleType-04775", + "text": " handleType must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA" + }, + { + "vuid": "VUID-VkMemoryGetZirconHandleInfoFUCHSIA-handleType-04776", + "text": " handleType must have been included in the handleTypes field of the VkExportMemoryAllocateInfo structure when the external memory was allocated" + } + ] + }, + "VkMemoryAllocateFlagsInfo": { + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkMemoryAllocateFlagsInfo-deviceMask-00675", + "text": " If VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT is set, deviceMask must be a valid device mask" + }, + { + "vuid": "VUID-VkMemoryAllocateFlagsInfo-deviceMask-00676", + "text": " If VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT is set, deviceMask must not be zero" + }, + { + "vuid": "VUID-VkMemoryAllocateFlagsInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO" + }, + { + "vuid": "VUID-VkMemoryAllocateFlagsInfo-flags-parameter", + "text": " flags must be a valid combination of VkMemoryAllocateFlagBits values" + } + ] + }, + "VkMemoryOpaqueCaptureAddressAllocateInfo": { + "(VK_VERSION_1_2,VK_KHR_buffer_device_address)": [ + { + "vuid": "VUID-VkMemoryOpaqueCaptureAddressAllocateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO" + } + ] + }, + "vkFreeMemory": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkFreeMemory-memory-00677", + "text": " All submitted commands that refer to memory (via images or buffers) must have completed execution" + } + ] + }, + "vkMapMemory": { + "core": [ + { + "vuid": "VUID-vkMapMemory-memory-00678", + "text": " memory must not be currently host mapped" + }, + { + "vuid": "VUID-vkMapMemory-offset-00679", + "text": " offset must be less than the size of memory" + }, + { + "vuid": "VUID-vkMapMemory-size-00680", + "text": " If size is not equal to VK_WHOLE_SIZE, size must be greater than 0" + }, + { + "vuid": "VUID-vkMapMemory-size-00681", + "text": " If size is not equal to VK_WHOLE_SIZE, size must be less than or equal to the size of the memory minus offset" + }, + { + "vuid": "VUID-vkMapMemory-memory-00682", + "text": " memory must have been created with a memory type that reports VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT" + }, + { + "vuid": "VUID-vkMapMemory-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkMapMemory-memory-parameter", + "text": " memory must be a valid VkDeviceMemory handle" + }, + { + "vuid": "VUID-vkMapMemory-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-vkMapMemory-ppData-parameter", + "text": " ppData must be a valid pointer to a pointer value" + }, + { + "vuid": "VUID-vkMapMemory-memory-parent", + "text": " memory must have been created, allocated, or retrieved from device" + } + ], + "(VK_KHR_device_group)": [ + { + "vuid": "VUID-vkMapMemory-memory-00683", + "text": " memory must not have been allocated with multiple instances" + } + ] + }, + "vkFlushMappedMemoryRanges": { + "core": [ + { + "vuid": "VUID-vkFlushMappedMemoryRanges-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkFlushMappedMemoryRanges-pMemoryRanges-parameter", + "text": " pMemoryRanges must be a valid pointer to an array of memoryRangeCount valid VkMappedMemoryRange structures" + }, + { + "vuid": "VUID-vkFlushMappedMemoryRanges-memoryRangeCount-arraylength", + "text": " memoryRangeCount must be greater than 0" + } + ] + }, + "vkInvalidateMappedMemoryRanges": { + "core": [ + { + "vuid": "VUID-vkInvalidateMappedMemoryRanges-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkInvalidateMappedMemoryRanges-pMemoryRanges-parameter", + "text": " pMemoryRanges must be a valid pointer to an array of memoryRangeCount valid VkMappedMemoryRange structures" + }, + { + "vuid": "VUID-vkInvalidateMappedMemoryRanges-memoryRangeCount-arraylength", + "text": " memoryRangeCount must be greater than 0" + } + ] + }, + "VkMappedMemoryRange": { + "core": [ + { + "vuid": "VUID-VkMappedMemoryRange-memory-00684", + "text": " memory must be currently host mapped" + }, + { + "vuid": "VUID-VkMappedMemoryRange-size-00685", + "text": " If size is not equal to VK_WHOLE_SIZE, offset and size must specify a range contained within the currently mapped range of memory" + }, + { + "vuid": "VUID-VkMappedMemoryRange-size-00686", + "text": " If size is equal to VK_WHOLE_SIZE, offset must be within the currently mapped range of memory" + }, + { + "vuid": "VUID-VkMappedMemoryRange-offset-00687", + "text": " offset must be a multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize" + }, + { + "vuid": "VUID-VkMappedMemoryRange-size-01389", + "text": " If size is equal to VK_WHOLE_SIZE, the end of the current mapping of memory must either be a multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize bytes from the beginning of the memory object, or be equal to the end of the memory object" + }, + { + "vuid": "VUID-VkMappedMemoryRange-size-01390", + "text": " If size is not equal to VK_WHOLE_SIZE, size must either be a multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize, or offset plus size must equal the size of memory" + }, + { + "vuid": "VUID-VkMappedMemoryRange-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE" + }, + { + "vuid": "VUID-VkMappedMemoryRange-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkMappedMemoryRange-memory-parameter", + "text": " memory must be a valid VkDeviceMemory handle" + } + ] + }, + "vkUnmapMemory": { + "core": [ + { + "vuid": "VUID-vkUnmapMemory-memory-00689", + "text": " memory must be currently host mapped" + }, + { + "vuid": "VUID-vkUnmapMemory-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkUnmapMemory-memory-parameter", + "text": " memory must be a valid VkDeviceMemory handle" + }, + { + "vuid": "VUID-vkUnmapMemory-memory-parent", + "text": " memory must have been created, allocated, or retrieved from device" + } + ] + }, + "vkGetDeviceMemoryCommitment": { + "core": [ + { + "vuid": "VUID-vkGetDeviceMemoryCommitment-memory-00690", + "text": " memory must have been created with a memory type that reports VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT" + }, + { + "vuid": "VUID-vkGetDeviceMemoryCommitment-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetDeviceMemoryCommitment-memory-parameter", + "text": " memory must be a valid VkDeviceMemory handle" + }, + { + "vuid": "VUID-vkGetDeviceMemoryCommitment-pCommittedMemoryInBytes-parameter", + "text": " pCommittedMemoryInBytes must be a valid pointer to a VkDeviceSize value" + }, + { + "vuid": "VUID-vkGetDeviceMemoryCommitment-memory-parent", + "text": " memory must have been created, allocated, or retrieved from device" + } + ] + }, + "vkGetDeviceGroupPeerMemoryFeatures": { + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkGetDeviceGroupPeerMemoryFeatures-heapIndex-00691", + "text": " heapIndex must be less than memoryHeapCount" + }, + { + "vuid": "VUID-vkGetDeviceGroupPeerMemoryFeatures-localDeviceIndex-00692", + "text": " localDeviceIndex must be a valid device index" + }, + { + "vuid": "VUID-vkGetDeviceGroupPeerMemoryFeatures-remoteDeviceIndex-00693", + "text": " remoteDeviceIndex must be a valid device index" + }, + { + "vuid": "VUID-vkGetDeviceGroupPeerMemoryFeatures-localDeviceIndex-00694", + "text": " localDeviceIndex must not equal remoteDeviceIndex" + }, + { + "vuid": "VUID-vkGetDeviceGroupPeerMemoryFeatures-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetDeviceGroupPeerMemoryFeatures-pPeerMemoryFeatures-parameter", + "text": " pPeerMemoryFeatures must be a valid pointer to a VkPeerMemoryFeatureFlags value" + } + ] + }, + "vkGetDeviceMemoryOpaqueCaptureAddress": { + "(VK_VERSION_1_2,VK_KHR_buffer_device_address)": [ + { + "vuid": "VUID-vkGetDeviceMemoryOpaqueCaptureAddress-None-03334", + "text": " The bufferDeviceAddress feature must be enabled" + }, + { + "vuid": "VUID-vkGetDeviceMemoryOpaqueCaptureAddress-device-03335", + "text": " If device was created with multiple physical devices, then the bufferDeviceAddressMultiDevice feature must be enabled" + }, + { + "vuid": "VUID-vkGetDeviceMemoryOpaqueCaptureAddress-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetDeviceMemoryOpaqueCaptureAddress-pInfo-parameter", + "text": " pInfo must be a valid pointer to a valid VkDeviceMemoryOpaqueCaptureAddressInfo structure" + } + ] + }, + "VkDeviceMemoryOpaqueCaptureAddressInfo": { + "(VK_VERSION_1_2,VK_KHR_buffer_device_address)": [ + { + "vuid": "VUID-VkDeviceMemoryOpaqueCaptureAddressInfo-memory-03336", + "text": " memory must have been allocated with VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT" + }, + { + "vuid": "VUID-VkDeviceMemoryOpaqueCaptureAddressInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO" + }, + { + "vuid": "VUID-VkDeviceMemoryOpaqueCaptureAddressInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDeviceMemoryOpaqueCaptureAddressInfo-memory-parameter", + "text": " memory must be a valid VkDeviceMemory handle" + } + ] + }, + "vkCreateBuffer": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateBuffer-flags-00911", + "text": " If the flags member of pCreateInfo includes VK_BUFFER_CREATE_SPARSE_BINDING_BIT, creating this VkBuffer must not cause the total required sparse memory for all currently valid sparse resources on the device to exceed VkPhysicalDeviceLimits::sparseAddressSpaceSize" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateBuffer-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "(VK_FUCHSIA_buffer_collection)": [ + { + "vuid": "VUID-vkCreateBuffer-pNext-06387", + "text": " If using the VkBuffer for an import operation from a VkBufferCollectionFUCHSIA where a VkBufferCollectionBufferCreateInfoFUCHSIA has been chained to pNext, pCreateInfo must match the VkBufferConstraintsInfoFUCHSIA::createInfo used when setting the constraints on the buffer collection with vkSetBufferCollectionBufferConstraintsFUCHSIA" + } + ], + "core": [ + { + "vuid": "VUID-vkCreateBuffer-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateBuffer-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkBufferCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateBuffer-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateBuffer-pBuffer-parameter", + "text": " pBuffer must be a valid pointer to a VkBuffer handle" + } + ] + }, + "VkBufferCreateInfo": { + "core": [ + { + "vuid": "VUID-VkBufferCreateInfo-size-00912", + "text": " size must be greater than 0" + }, + { + "vuid": "VUID-VkBufferCreateInfo-sharingMode-00913", + "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a valid pointer to an array of queueFamilyIndexCount uint32_t values" + }, + { + "vuid": "VUID-VkBufferCreateInfo-sharingMode-00914", + "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1" + }, + { + "vuid": "VUID-VkBufferCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO" + }, + { + "vuid": "VUID-VkBufferCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkBufferOpaqueCaptureAddressCreateInfo or VkExternalMemoryBufferCreateInfo" + }, + { + "vuid": "VUID-VkBufferCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkBufferCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkBufferCreateFlagBits values" + }, + { + "vuid": "VUID-VkBufferCreateInfo-usage-parameter", + "text": " usage must be a valid combination of VkBufferUsageFlagBits values" + }, + { + "vuid": "VUID-VkBufferCreateInfo-usage-requiredbitmask", + "text": " usage must not be 0" + }, + { + "vuid": "VUID-VkBufferCreateInfo-sharingMode-parameter", + "text": " sharingMode must be a valid VkSharingMode value" + } + ], + "!(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkBufferCreateInfo-sharingMode-01391", + "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the physicalDevice that was used to create device" + } + ], + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkBufferCreateInfo-sharingMode-01419", + "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device" + } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkBufferCreateInfo-flags-00915", + "text": " If the sparse bindings feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT" + }, + { + "vuid": "VUID-VkBufferCreateInfo-flags-00916", + "text": " If the sparse buffer residency feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkBufferCreateInfo-flags-00917", + "text": " If the sparse aliased residency feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_ALIASED_BIT" + }, + { + "vuid": "VUID-VkBufferCreateInfo-flags-00918", + "text": " If flags contains VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkBufferCreateInfo-flags-05061", + "text": " flags must not contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT, VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT" + } + ], + "(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkBufferCreateInfo-pNext-00920", + "text": " If the pNext chain includes a VkExternalMemoryBufferCreateInfo structure, its handleTypes member must only contain bits that are also in VkExternalBufferProperties::externalMemoryProperties.compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalBufferProperties with pExternalBufferInfo->handleType equal to any one of the handle types specified in VkExternalMemoryBufferCreateInfo::handleTypes" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkBufferCreateInfo-flags-01887", + "text": " If the protected memory feature is not enabled, flags must not contain VK_BUFFER_CREATE_PROTECTED_BIT" + } + ], + "(VK_VERSION_1_1)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkBufferCreateInfo-None-01888", + "text": " If any of the bits VK_BUFFER_CREATE_SPARSE_BINDING_BIT, VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT are set, VK_BUFFER_CREATE_PROTECTED_BIT must not also be set" + } + ], + "(VK_NV_dedicated_allocation)": [ + { + "vuid": "VUID-VkBufferCreateInfo-pNext-01571", + "text": " If the pNext chain includes a VkDedicatedAllocationBufferCreateInfoNV structure, and the dedicatedAllocation member of the chained structure is VK_TRUE, then flags must not include VK_BUFFER_CREATE_SPARSE_BINDING_BIT, VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT" + } + ], + "(VK_VERSION_1_2,VK_EXT_buffer_device_address,VK_KHR_buffer_device_address)+(VK_EXT_buffer_device_address)": [ + { + "vuid": "VUID-VkBufferCreateInfo-deviceAddress-02604", + "text": " If VkBufferDeviceAddressCreateInfoEXT::deviceAddress is not zero, flags must include VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT" + }, + { + "vuid": "VUID-VkBufferCreateInfo-flags-03338", + "text": " If flags includes VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, the bufferDeviceAddressCaptureReplay or VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::bufferDeviceAddressCaptureReplay feature must be enabled" + } + ], + "(VK_VERSION_1_2,VK_EXT_buffer_device_address,VK_KHR_buffer_device_address)+(VK_VERSION_1_2,VK_KHR_buffer_device_address)": [ + { + "vuid": "VUID-VkBufferCreateInfo-opaqueCaptureAddress-03337", + "text": " If VkBufferOpaqueCaptureAddressCreateInfo::opaqueCaptureAddress is not zero, flags must include VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT" + } + ], + "(VK_VERSION_1_2,VK_EXT_buffer_device_address,VK_KHR_buffer_device_address)+!(VK_EXT_buffer_device_address)": [ + { + "vuid": "VUID-VkBufferCreateInfo-flags-06549", + "text": " If flags includes VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, the bufferDeviceAddressCaptureReplay feature must be enabled" + } + ], + "(VK_KHR_video_decode_queue)": [ + { + "vuid": "VUID-VkBufferCreateInfo-usage-04813", + "text": " If usage includes VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR, VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR, then the pNext chain must include a valid VkVideoProfilesKHR structure which includes at least one VkVideoProfileKHR with a decode codec-operation" + } + ], + "(VK_KHR_video_encode_queue)": [ + { + "vuid": "VUID-VkBufferCreateInfo-usage-04814", + "text": " If usage includes VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR, VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR, then the pNext chain must include a valid VkVideoProfilesKHR structure which includes at least one VkVideoProfileKHR with a encode codec-operation" + } + ], + "(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-VkBufferCreateInfo-size-06409", + "text": " size must be less than or equal to VkPhysicalDeviceMaintenance4PropertiesKHR::maxBufferSize" + } + ] + }, + "VkExternalMemoryBufferCreateInfo": { + "(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkExternalMemoryBufferCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO" + }, + { + "vuid": "VUID-VkExternalMemoryBufferCreateInfo-handleTypes-parameter", + "text": " handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBits values" + } + ] + }, + "VkBufferOpaqueCaptureAddressCreateInfo": { + "(VK_VERSION_1_2,VK_KHR_buffer_device_address)": [ + { + "vuid": "VUID-VkBufferOpaqueCaptureAddressCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO" + } + ] + }, + "VkBufferCollectionBufferCreateInfoFUCHSIA": { + "(VK_FUCHSIA_buffer_collection)": [ + { + "vuid": "VUID-VkBufferCollectionBufferCreateInfoFUCHSIA-index-06388", + "text": " index must be less than VkBufferCollectionPropertiesFUCHSIA::bufferCount" + } + ] + }, + "vkDestroyBuffer": { + "core": [ + { + "vuid": "VUID-vkDestroyBuffer-buffer-00922", + "text": " All submitted commands that refer to buffer, either directly or via a VkBufferView, must have completed execution" + }, + { + "vuid": "VUID-vkDestroyBuffer-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyBuffer-buffer-parameter", + "text": " If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkDestroyBuffer-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyBuffer-buffer-parent", + "text": " If buffer is a valid handle, it must have been created, allocated, or retrieved from device" + } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyBuffer-buffer-00923", + "text": " If VkAllocationCallbacks were provided when buffer was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyBuffer-buffer-00924", + "text": " If no VkAllocationCallbacks were provided when buffer was created, pAllocator must be NULL" + } + ] + }, + "vkCreateBufferView": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateBufferView-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "core": [ + { + "vuid": "VUID-vkCreateBufferView-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateBufferView-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkBufferViewCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateBufferView-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateBufferView-pView-parameter", + "text": " pView must be a valid pointer to a VkBufferView handle" + } + ] + }, + "VkBufferViewCreateInfo": { + "core": [ + { + "vuid": "VUID-VkBufferViewCreateInfo-offset-00925", + "text": " offset must be less than the size of buffer" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-range-00928", + "text": " If range is not equal to VK_WHOLE_SIZE, range must be greater than 0" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-range-00929", + "text": " If range is not equal to VK_WHOLE_SIZE, range must be an integer multiple of the texel block size of format" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-range-00930", + "text": " If range is not equal to VK_WHOLE_SIZE, the number of texel buffer elements given by ({lfloor}range / (texel block size){rfloor} {times} (texels per block)) where texel block size and texels per block are as defined in the Compatible Formats table for format, must be less than or equal to VkPhysicalDeviceLimits::maxTexelBufferElements" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-offset-00931", + "text": " If range is not equal to VK_WHOLE_SIZE, the sum of offset and range must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-range-04059", + "text": " If range is equal to VK_WHOLE_SIZE, the number of texel buffer elements given by ({lfloor}(size - offset) / (texel block size){rfloor} {times} (texels per block)) where size is the size of buffer, and texel block size and texels per block are as defined in the Compatible Formats table for format, must be less than or equal to VkPhysicalDeviceLimits::maxTexelBufferElements" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-buffer-00932", + "text": " buffer must have been created with a usage value containing at least one of VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-buffer-00933", + "text": " If buffer was created with usage containing VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, format must be supported for uniform texel buffers, as specified by the VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT flag in VkFormatProperties::bufferFeatures returned by vkGetPhysicalDeviceFormatProperties" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-buffer-00934", + "text": " If buffer was created with usage containing VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, format must be supported for storage texel buffers, as specified by the VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT flag in VkFormatProperties::bufferFeatures returned by vkGetPhysicalDeviceFormatProperties" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-buffer-00935", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-format-parameter", + "text": " format must be a valid VkFormat value" + } + ], + "!(VK_EXT_texel_buffer_alignment)": [ + { + "vuid": "VUID-VkBufferViewCreateInfo-offset-00926", + "text": " offset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment" + } + ], + "(VK_EXT_texel_buffer_alignment)": [ + { + "vuid": "VUID-VkBufferViewCreateInfo-offset-02749", + "text": " If the texelBufferAlignment feature is not enabled, offset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-buffer-02750", + "text": " If the texelBufferAlignment feature is enabled and if buffer was created with usage containing VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, offset must be a multiple of the lesser of VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::storageTexelBufferOffsetAlignmentBytes or, if VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::storageTexelBufferOffsetSingleTexelAlignment is VK_TRUE, the size of a texel of the requested format. If the size of a texel is a multiple of three bytes, then the size of a single component of format is used instead" + }, + { + "vuid": "VUID-VkBufferViewCreateInfo-buffer-02751", + "text": " If the texelBufferAlignment feature is enabled and if buffer was created with usage containing VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, offset must be a multiple of the lesser of VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::uniformTexelBufferOffsetAlignmentBytes or, if VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::uniformTexelBufferOffsetSingleTexelAlignment is VK_TRUE, the size of a texel of the requested format. If the size of a texel is a multiple of three bytes, then the size of a single component of format is used instead" + } + ] + }, + "vkDestroyBufferView": { + "core": [ + { + "vuid": "VUID-vkDestroyBufferView-bufferView-00936", + "text": " All submitted commands that refer to bufferView must have completed execution" + }, + { + "vuid": "VUID-vkDestroyBufferView-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyBufferView-bufferView-parameter", + "text": " If bufferView is not VK_NULL_HANDLE, bufferView must be a valid VkBufferView handle" + }, + { + "vuid": "VUID-vkDestroyBufferView-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyBufferView-bufferView-parent", + "text": " If bufferView is a valid handle, it must have been created, allocated, or retrieved from device" + } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyBufferView-bufferView-00937", + "text": " If VkAllocationCallbacks were provided when bufferView was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyBufferView-bufferView-00938", + "text": " If no VkAllocationCallbacks were provided when bufferView was created, pAllocator must be NULL" + } + ] + }, + "vkCreateImage": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateImage-flags-00939", + "text": " If the flags member of pCreateInfo includes VK_IMAGE_CREATE_SPARSE_BINDING_BIT, creating this VkImage must not cause the total required sparse memory for all currently valid sparse resources on the device to exceed VkPhysicalDeviceLimits::sparseAddressSpaceSize" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateImage-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "(VK_FUCHSIA_buffer_collection)": [ + { + "vuid": "VUID-vkCreateImage-pNext-06389", + "text": " If a VkBufferCollectionImageCreateInfoFUCHSIA has been chained to pNext, pCreateInfo must match the Sysmem chosen VkImageCreateInfo excepting members VkImageCreateInfo::extent and VkImageCreateInfo::usage in the match criteria" + } + ], + "core": [ + { + "vuid": "VUID-vkCreateImage-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateImage-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkImageCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateImage-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateImage-pImage-parameter", + "text": " pImage must be a valid pointer to a VkImage handle" + } + ] + }, + "VkImageCreateInfo": { + "core": [ + { + "vuid": "VUID-VkImageCreateInfo-imageCreateMaxMipLevels-02251", + "text": " Each of the following values (as described in Image Creation Limits) must not be undefined : imageCreateMaxMipLevels, imageCreateMaxArrayLayers, imageCreateMaxExtent, and imageCreateSampleCounts" + }, + { + "vuid": "VUID-VkImageCreateInfo-sharingMode-00941", + "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a valid pointer to an array of queueFamilyIndexCount uint32_t values" + }, + { + "vuid": "VUID-VkImageCreateInfo-sharingMode-00942", + "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1" + }, + { + "vuid": "VUID-VkImageCreateInfo-extent-00944", + "text": " extent.width must be greater than 0" + }, + { + "vuid": "VUID-VkImageCreateInfo-extent-00945", + "text": " extent.height must be greater than 0" + }, + { + "vuid": "VUID-VkImageCreateInfo-extent-00946", + "text": " extent.depth must be greater than 0" + }, + { + "vuid": "VUID-VkImageCreateInfo-mipLevels-00947", + "text": " mipLevels must be greater than 0" + }, + { + "vuid": "VUID-VkImageCreateInfo-arrayLayers-00948", + "text": " arrayLayers must be greater than 0" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-00949", + "text": " If flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, imageType must be VK_IMAGE_TYPE_2D" + }, + { + "vuid": "VUID-VkImageCreateInfo-extent-02252", + "text": " extent.width must be less than or equal to imageCreateMaxExtent.width (as defined in Image Creation Limits)" + }, + { + "vuid": "VUID-VkImageCreateInfo-extent-02253", + "text": " extent.height must be less than or equal to imageCreateMaxExtent.height (as defined in Image Creation Limits)" + }, + { + "vuid": "VUID-VkImageCreateInfo-extent-02254", + "text": " extent.depth must be less than or equal to imageCreateMaxExtent.depth (as defined in Image Creation Limits)" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00954", + "text": " If imageType is VK_IMAGE_TYPE_2D and flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, extent.width and extent.height must be equal and arrayLayers must be greater than or equal to 6" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00956", + "text": " If imageType is VK_IMAGE_TYPE_1D, both extent.height and extent.depth must be 1" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00957", + "text": " If imageType is VK_IMAGE_TYPE_2D, extent.depth must be 1" + }, + { + "vuid": "VUID-VkImageCreateInfo-mipLevels-00958", + "text": " mipLevels must be less than or equal to the number of levels in the complete mipmap chain based on extent.width, extent.height, and extent.depth" + }, + { + "vuid": "VUID-VkImageCreateInfo-mipLevels-02255", + "text": " mipLevels must be less than or equal to imageCreateMaxMipLevels (as defined in Image Creation Limits)" + }, + { + "vuid": "VUID-VkImageCreateInfo-arrayLayers-02256", + "text": " arrayLayers must be less than or equal to imageCreateMaxArrayLayers (as defined in Image Creation Limits)" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00961", + "text": " If imageType is VK_IMAGE_TYPE_3D, arrayLayers must be 1" + }, + { + "vuid": "VUID-VkImageCreateInfo-samples-02257", + "text": " If samples is not VK_SAMPLE_COUNT_1_BIT, then imageType must be VK_IMAGE_TYPE_2D, flags must not contain VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, mipLevels must be equal to 1, and imageCreateMaybeLinear (as defined in Image Creation Limits) must be VK_FALSE," + }, + { + "vuid": "VUID-VkImageCreateInfo-usage-00963", + "text": " If usage includes VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, then bits other than VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, and VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT must not be set" + }, + { + "vuid": "VUID-VkImageCreateInfo-usage-00964", + "text": " If usage includes VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, extent.width must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferWidth" + }, + { + "vuid": "VUID-VkImageCreateInfo-usage-00965", + "text": " If usage includes VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, extent.height must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferHeight" + }, + { + "vuid": "VUID-VkImageCreateInfo-usage-00966", + "text": " If usage includes VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, usage must also contain at least one of VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-samples-02258", + "text": " samples must be a bit value that is set in imageCreateSampleCounts (as defined in Image Creation Limits)" + }, + { + "vuid": "VUID-VkImageCreateInfo-usage-00968", + "text": " If the multisampled storage images feature is not enabled, and usage contains VK_IMAGE_USAGE_STORAGE_BIT, samples must be VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-initialLayout-00993", + "text": " initialLayout must be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED" + }, + { + "vuid": "VUID-VkImageCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO" + }, + { + "vuid": "VUID-VkImageCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkExternalMemoryImageCreateInfo, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, or VkImageSwapchainCreateInfoKHR" + }, + { + "vuid": "VUID-VkImageCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkImageCreateFlagBits values" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-parameter", + "text": " imageType must be a valid VkImageType value" + }, + { + "vuid": "VUID-VkImageCreateInfo-format-parameter", + "text": " format must be a valid VkFormat value" + }, + { + "vuid": "VUID-VkImageCreateInfo-samples-parameter", + "text": " samples must be a valid VkSampleCountFlagBits value" + }, + { + "vuid": "VUID-VkImageCreateInfo-tiling-parameter", + "text": " tiling must be a valid VkImageTiling value" + }, + { + "vuid": "VUID-VkImageCreateInfo-usage-parameter", + "text": " usage must be a valid combination of VkImageUsageFlagBits values" + }, + { + "vuid": "VUID-VkImageCreateInfo-usage-requiredbitmask", + "text": " usage must not be 0" + }, + { + "vuid": "VUID-VkImageCreateInfo-sharingMode-parameter", + "text": " sharingMode must be a valid VkSharingMode value" + }, + { + "vuid": "VUID-VkImageCreateInfo-initialLayout-parameter", + "text": " initialLayout must be a valid VkImageLayout value" + } + ], + "!(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkImageCreateInfo-sharingMode-01392", + "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the physicalDevice that was used to create device" + } + ], + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkImageCreateInfo-sharingMode-01420", + "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device" + } + ], + "!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkImageCreateInfo-format-00943", + "text": " format must not be VK_FORMAT_UNDEFINED" + } + ], + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkImageCreateInfo-pNext-01974", + "text": " If the pNext chain includes a VkExternalFormatANDROID structure, and its externalFormat member is non-zero the format must be VK_FORMAT_UNDEFINED" + }, + { + "vuid": "VUID-VkImageCreateInfo-pNext-01975", + "text": " If the pNext chain does not include a VkExternalFormatANDROID structure, or does and its externalFormat member is 0, the format must not be VK_FORMAT_UNDEFINED" + }, + { + "vuid": "VUID-VkImageCreateInfo-pNext-02393", + "text": " If the pNext chain includes a VkExternalMemoryImageCreateInfo structure whose handleTypes member includes VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, imageType must be VK_IMAGE_TYPE_2D" + }, + { + "vuid": "VUID-VkImageCreateInfo-pNext-02394", + "text": " If the pNext chain includes a VkExternalMemoryImageCreateInfo structure whose handleTypes member includes VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, mipLevels must either be 1 or equal to the number of levels in the complete mipmap chain based on extent.width, extent.height, and extent.depth" + }, + { + "vuid": "VUID-VkImageCreateInfo-pNext-02396", + "text": " If the pNext chain includes a VkExternalFormatANDROID structure whose externalFormat member is not 0, flags must not include VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-pNext-02397", + "text": " If the pNext chain includes a VkExternalFormatANDROID structure whose externalFormat member is not 0, usage must not include any usages except VK_IMAGE_USAGE_SAMPLED_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-pNext-02398", + "text": " If the pNext chain includes a VkExternalFormatANDROID structure whose externalFormat member is not 0, tiling must be VK_IMAGE_TILING_OPTIMAL" + } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkImageCreateInfo-flags-02557", + "text": " If flags contains VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, imageType must be VK_IMAGE_TYPE_2D" + }, + { + "vuid": "VUID-VkImageCreateInfo-samples-02558", + "text": " If samples is not VK_SAMPLE_COUNT_1_BIT, usage must not contain VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT" + }, + { + "vuid": "VUID-VkImageCreateInfo-usage-02559", + "text": " If usage includes VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, extent.width must be less than or equal to \\(\\left\\lceil{\\frac{maxFramebufferWidth}{minFragmentDensityTexelSize_{width}}}\\right\\rceil\\)" + }, + { + "vuid": "VUID-VkImageCreateInfo-usage-02560", + "text": " If usage includes VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, extent.height must be less than or equal to \\(\\left\\lceil{\\frac{maxFramebufferHeight}{minFragmentDensityTexelSize_{height}}}\\right\\rceil\\)" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-02565", + "text": " If flags contains VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT, tiling must be VK_IMAGE_TILING_OPTIMAL" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-02566", + "text": " If flags contains VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT, imageType must be VK_IMAGE_TYPE_2D" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-02567", + "text": " If flags contains VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT, flags must not contain VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-02568", + "text": " If flags contains VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT, mipLevels must be 1" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkImageCreateInfo-flags-00950", + "text": " If flags contains VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, imageType must be VK_IMAGE_TYPE_3D" + } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkImageCreateInfo-flags-00969", + "text": " If the sparse bindings feature is not enabled, flags must not contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-01924", + "text": " If the sparse aliased residency feature is not enabled, flags must not contain VK_IMAGE_CREATE_SPARSE_ALIASED_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-tiling-04121", + "text": " If tiling is VK_IMAGE_TILING_LINEAR, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00970", + "text": " If imageType is VK_IMAGE_TYPE_1D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00971", + "text": " If the sparse residency for 2D images feature is not enabled, and imageType is VK_IMAGE_TYPE_2D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00972", + "text": " If the sparse residency for 3D images feature is not enabled, and imageType is VK_IMAGE_TYPE_3D, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00973", + "text": " If the sparse residency for images with 2 samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_2_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00974", + "text": " If the sparse residency for images with 4 samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_4_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00975", + "text": " If the sparse residency for images with 8 samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_8_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageType-00976", + "text": " If the sparse residency for images with 16 samples feature is not enabled, imageType is VK_IMAGE_TYPE_2D, and samples is VK_SAMPLE_COUNT_16_BIT, flags must not contain VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-00987", + "text": " If flags contains VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-None-01925", + "text": " If any of the bits VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT are set, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT must not also be set" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkImageCreateInfo-flags-05062", + "text": " flags must not contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, or VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkImageCreateInfo-flags-01890", + "text": " If the protected memory feature is not enabled, flags must not contain VK_IMAGE_CREATE_PROTECTED_BIT" + } + ], + "(VK_VERSION_1_1)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkImageCreateInfo-None-01891", + "text": " If any of the bits VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT are set, VK_IMAGE_CREATE_PROTECTED_BIT must not also be set" + } + ], + "(VK_VERSION_1_1,VK_KHR_external_memory)+(VK_NV_external_memory)": [ + { + "vuid": "VUID-VkImageCreateInfo-pNext-00988", + "text": " If the pNext chain includes a VkExternalMemoryImageCreateInfoNV structure, it must not contain a VkExternalMemoryImageCreateInfo structure" + } + ], + "(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkImageCreateInfo-pNext-00990", + "text": " If the pNext chain includes a VkExternalMemoryImageCreateInfo structure, its handleTypes member must only contain bits that are also in VkExternalImageFormatProperties::externalMemoryProperties.compatibleHandleTypes, as returned by vkGetPhysicalDeviceImageFormatProperties2 with format, imageType, tiling, usage, and flags equal to those in this structure, and with a VkPhysicalDeviceExternalImageFormatInfo structure included in the pNext chain, with a handleType equal to any one of the handle types specified in VkExternalMemoryImageCreateInfo::handleTypes" + } + ], + "(VK_NV_external_memory+VK_NV_external_memory_capabilities)": [ + { + "vuid": "VUID-VkImageCreateInfo-pNext-00991", + "text": " If the pNext chain includes a VkExternalMemoryImageCreateInfoNV structure, its handleTypes member must only contain bits that are also in VkExternalImageFormatPropertiesNV::externalMemoryProperties.compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalImageFormatPropertiesNV with format, imageType, tiling, usage, and flags equal to those in this structure, and with externalHandleType equal to any one of the handle types specified in VkExternalMemoryImageCreateInfoNV::handleTypes" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkImageCreateInfo-physicalDeviceCount-01421", + "text": " If the logical device was created with VkDeviceGroupDeviceCreateInfo::physicalDeviceCount equal to 1, flags must not contain VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-02259", + "text": " If flags contains VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, then mipLevels must be one, arrayLayers must be one, imageType must be VK_IMAGE_TYPE_2D. and imageCreateMaybeLinear (as defined in Image Creation Limits) must be VK_FALSE" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkImageCreateInfo-flags-01572", + "text": " If flags contains VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, then format must be a compressed image format" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-01573", + "text": " If flags contains VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, then flags must also contain VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT" + } + ], + "(VK_VERSION_1_1,VK_KHR_external_memory,VK_NV_external_memory)": [ + { + "vuid": "VUID-VkImageCreateInfo-pNext-01443", + "text": " If the pNext chain includes a VkExternalMemoryImageCreateInfo or VkExternalMemoryImageCreateInfoNV structure whose handleTypes member is not 0, initialLayout must be VK_IMAGE_LAYOUT_UNDEFINED" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageCreateInfo-format-06410", + "text": " If the image format is one of the formats that require a sampler Y’CBCR conversion, mipLevels must be 1" + }, + { + "vuid": "VUID-VkImageCreateInfo-format-06411", + "text": " If the image format is one of the formats that require a sampler Y’CBCR conversion, samples must be VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-format-06412", + "text": " If the image format is one of the formats that require a sampler Y’CBCR conversion, imageType must be VK_IMAGE_TYPE_2D" + }, + { + "vuid": "VUID-VkImageCreateInfo-imageCreateFormatFeatures-02260", + "text": " If format is a multi-planar format, and if imageCreateFormatFeatures (as defined in Image Creation Limits) does not contain VK_FORMAT_FEATURE_DISJOINT_BIT, then flags must not contain VK_IMAGE_CREATE_DISJOINT_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-format-01577", + "text": " If format is not a multi-planar format, and flags does not include VK_IMAGE_CREATE_ALIAS_BIT, flags must not contain VK_IMAGE_CREATE_DISJOINT_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-format-04712", + "text": " If format has a _422 or _420 suffix, width must be a multiple of 2" + }, + { + "vuid": "VUID-VkImageCreateInfo-format-04713", + "text": " If format has a _420 suffix, height must be a multiple of 2" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_ycbcr_image_arrays)": [ + { + "vuid": "VUID-VkImageCreateInfo-format-06413", + "text": " If the image format is one of the formats that require a sampler Y’CBCR conversion, and the ycbcrImageArrays feature is not enabled, arrayLayers must be 1" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_ycbcr_image_arrays)": [ + { + "vuid": "VUID-VkImageCreateInfo-format-06414", + "text": " If the image format is one of the formats that require a sampler Y’CBCR conversion, arrayLayers must be 1" + } + ], + "(VK_EXT_image_drm_format_modifier)": [ + { + "vuid": "VUID-VkImageCreateInfo-tiling-02261", + "text": " If tiling is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then the pNext chain must include exactly one of VkImageDrmFormatModifierListCreateInfoEXT or VkImageDrmFormatModifierExplicitCreateInfoEXT structures" + }, + { + "vuid": "VUID-VkImageCreateInfo-pNext-02262", + "text": " If the pNext chain includes a VkImageDrmFormatModifierListCreateInfoEXT or VkImageDrmFormatModifierExplicitCreateInfoEXT structure, then tiling must be VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT" + }, + { + "vuid": "VUID-VkImageCreateInfo-tiling-02353", + "text": " If tiling is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT and flags contains VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, then the pNext chain must include a VkImageFormatListCreateInfo structure with non-zero viewFormatCount" + } + ], + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-VkImageCreateInfo-flags-01533", + "text": " If flags contains VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT format must be a depth or depth/stencil format" + } + ], + "(VK_VERSION_1_2,VK_EXT_separate_stencil_usage)": [ + { + "vuid": "VUID-VkImageCreateInfo-format-02795", + "text": " If format is a depth-stencil format, usage includes VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, and the pNext chain includes a VkImageStencilUsageCreateInfo structure, then its VkImageStencilUsageCreateInfo::stencilUsage member must also include VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-format-02796", + "text": " If format is a depth-stencil format, usage does not include VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, and the pNext chain includes a VkImageStencilUsageCreateInfo structure, then its VkImageStencilUsageCreateInfo::stencilUsage member must also not include VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-format-02797", + "text": " If format is a depth-stencil format, usage includes VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, and the pNext chain includes a VkImageStencilUsageCreateInfo structure, then its VkImageStencilUsageCreateInfo::stencilUsage member must also include VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-format-02798", + "text": " If format is a depth-stencil format, usage does not include VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, and the pNext chain includes a VkImageStencilUsageCreateInfo structure, then its VkImageStencilUsageCreateInfo::stencilUsage member must also not include VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-Format-02536", + "text": " If Format is a depth-stencil format and the pNext chain includes a VkImageStencilUsageCreateInfo structure with its stencilUsage member including VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, extent.width must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferWidth" + }, + { + "vuid": "VUID-VkImageCreateInfo-format-02537", + "text": " If format is a depth-stencil format and the pNext chain includes a VkImageStencilUsageCreateInfo structure with its stencilUsage member including VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, extent.height must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferHeight" + }, + { + "vuid": "VUID-VkImageCreateInfo-format-02538", + "text": " If the multisampled storage images feature is not enabled, format is a depth-stencil format and the pNext chain includes a VkImageStencilUsageCreateInfo structure with its stencilUsage including VK_IMAGE_USAGE_STORAGE_BIT, samples must be VK_SAMPLE_COUNT_1_BIT" + } + ], + "(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-VkImageCreateInfo-flags-02050", + "text": " If flags contains VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV, imageType must be VK_IMAGE_TYPE_2D or VK_IMAGE_TYPE_3D" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-02051", + "text": " If flags contains VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV, it must not contain VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT and the format must not be a depth/stencil format" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-02052", + "text": " If flags contains VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV and imageType is VK_IMAGE_TYPE_2D, extent.width and extent.height must be greater than 1" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-02053", + "text": " If flags contains VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV and imageType is VK_IMAGE_TYPE_3D, extent.width, extent.height, and extent.depth must be greater than 1" + } + ], + "(VK_KHR_fragment_shading_rate,VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkImageCreateInfo-imageType-02082", + "text": " If usage includes VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, imageType must be VK_IMAGE_TYPE_2D" + }, + { + "vuid": "VUID-VkImageCreateInfo-samples-02083", + "text": " If usage includes VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, samples must be VK_SAMPLE_COUNT_1_BIT" + } + ], + "(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkImageCreateInfo-tiling-02084", + "text": " If usage includes VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, tiling must be VK_IMAGE_TILING_OPTIMAL" + } + ], + "(VK_HUAWEI_invocation_mask)": [ + { + "vuid": "VUID-VkImageCreateInfo-usage-04992", + "text": " If usage includes VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI, tiling must be VK_IMAGE_TILING_LINEAR" + } + ], + "(VK_KHR_portability_subset)": [ + { + "vuid": "VUID-VkImageCreateInfo-imageView2DOn3DImage-04459", + "text": " If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::imageView2DOn3DImage is VK_FALSE, flags must not contain VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT" + }, + { + "vuid": "VUID-VkImageCreateInfo-multisampleArrayImage-04460", + "text": " If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::multisampleArrayImage is VK_FALSE, and samples is not VK_SAMPLE_COUNT_1_BIT, then arrayLayers must be 1" + } + ], + "(VK_VERSION_1_2,VK_KHR_image_format_list)": [ + { + "vuid": "VUID-VkImageCreateInfo-pNext-04737", + "text": " If a VkImageFormatListCreateInfo structure was included in the pNext chain and VkImageFormatListCreateInfo::viewFormatCount is not zero, then all of the formats in VkImageFormatListCreateInfo::pViewFormats must be compatible with the format as described in the compatibility table" + }, + { + "vuid": "VUID-VkImageCreateInfo-flags-04738", + "text": " If flags does not contain VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT and the pNext chain includes a VkImageFormatListCreateInfo structure, then VkImageFormatListCreateInfo::viewFormatCount must be 0 or 1" + } + ], + "(VK_KHR_video_decode_queue)": [ + { + "vuid": "VUID-VkImageCreateInfo-usage-04815", + "text": " If usage includes VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR, VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR, VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR, then the pNext chain must include a valid VkVideoProfilesKHR structure which includes at least one VkVideoProfileKHR with a decode codec-operation" + } + ], + "(VK_KHR_video_encode_queue)": [ + { + "vuid": "VUID-VkImageCreateInfo-usage-04816", + "text": " If usage includes VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR, VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR, VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR, then the pNext chain must include a valid VkVideoProfilesKHR structure which includes at least one VkVideoProfileKHR with a encode codec-operation" + } + ], + "(VK_FUCHSIA_buffer_collection)": [ + { + "vuid": "VUID-VkImageCreateInfo-pNext-06390", + "text": " If the VkImage is to be used to import memory from a VkBufferCollectionFUCHSIA, a VkBufferCollectionImageCreateInfoFUCHSIA structure must be chained to pNext." + } + ] + }, + "VkBufferCollectionImageCreateInfoFUCHSIA": { + "(VK_FUCHSIA_buffer_collection)": [ + { + "vuid": "VUID-VkBufferCollectionImageCreateInfoFUCHSIA-index-06391", + "text": " index must be less than VkBufferCollectionPropertiesFUCHSIA::bufferCount" + } + ] + }, + "VkImageStencilUsageCreateInfo": { + "(VK_VERSION_1_2,VK_EXT_separate_stencil_usage)": [ + { + "vuid": "VUID-VkImageStencilUsageCreateInfo-stencilUsage-02539", + "text": " If stencilUsage includes VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, it must not include bits other than VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageStencilUsageCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO" + }, + { + "vuid": "VUID-VkImageStencilUsageCreateInfo-stencilUsage-parameter", + "text": " stencilUsage must be a valid combination of VkImageUsageFlagBits values" + }, + { + "vuid": "VUID-VkImageStencilUsageCreateInfo-stencilUsage-requiredbitmask", + "text": " stencilUsage must not be 0" + } + ] + }, + "VkDedicatedAllocationImageCreateInfoNV": { + "(VK_NV_dedicated_allocation)": [ + { + "vuid": "VUID-VkDedicatedAllocationImageCreateInfoNV-dedicatedAllocation-00994", + "text": " If dedicatedAllocation is VK_TRUE, VkImageCreateInfo::flags must not include VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT" + } + ] + }, + "VkExternalMemoryImageCreateInfo": { + "(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkExternalMemoryImageCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO" + }, + { + "vuid": "VUID-VkExternalMemoryImageCreateInfo-handleTypes-parameter", + "text": " handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBits values" + } + ] + }, + "VkExternalFormatANDROID": { + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkExternalFormatANDROID-externalFormat-01894", + "text": " externalFormat must be 0 or a value returned in the externalFormat member of VkAndroidHardwareBufferFormatPropertiesANDROID by an earlier call to vkGetAndroidHardwareBufferPropertiesANDROID" + } + ] + }, + "VkImageSwapchainCreateInfoKHR": { + "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)": [ + { + "vuid": "VUID-VkImageSwapchainCreateInfoKHR-swapchain-00995", + "text": " If swapchain is not VK_NULL_HANDLE, the fields of VkImageCreateInfo must match the implied image creation parameters of the swapchain" + }, + { + "vuid": "VUID-VkImageSwapchainCreateInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR" + }, + { + "vuid": "VUID-VkImageSwapchainCreateInfoKHR-swapchain-parameter", + "text": " If swapchain is not VK_NULL_HANDLE, swapchain must be a valid VkSwapchainKHR handle" + } + ] + }, + "VkImageFormatListCreateInfo": { + "(VK_VERSION_1_2,VK_KHR_image_format_list)": [ + { + "vuid": "VUID-VkImageFormatListCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO" + }, + { + "vuid": "VUID-VkImageFormatListCreateInfo-pViewFormats-parameter", + "text": " If viewFormatCount is not 0, pViewFormats must be a valid pointer to an array of viewFormatCount valid VkFormat values" + } + ] + }, + "VkImageDrmFormatModifierListCreateInfoEXT": { + "(VK_EXT_image_drm_format_modifier)": [ + { + "vuid": "VUID-VkImageDrmFormatModifierListCreateInfoEXT-pDrmFormatModifiers-02263", + "text": " Each modifier in pDrmFormatModifiers must be compatible with the parameters in VkImageCreateInfo and its pNext chain, as determined by querying VkPhysicalDeviceImageFormatInfo2 extended with VkPhysicalDeviceImageDrmFormatModifierInfoEXT" + }, + { + "vuid": "VUID-VkImageDrmFormatModifierListCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkImageDrmFormatModifierListCreateInfoEXT-pDrmFormatModifiers-parameter", + "text": " pDrmFormatModifiers must be a valid pointer to an array of drmFormatModifierCount uint64_t values" + }, + { + "vuid": "VUID-VkImageDrmFormatModifierListCreateInfoEXT-drmFormatModifierCount-arraylength", + "text": " drmFormatModifierCount must be greater than 0" + } + ] + }, + "VkImageDrmFormatModifierExplicitCreateInfoEXT": { + "(VK_EXT_image_drm_format_modifier)": [ + { + "vuid": "VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-drmFormatModifier-02264", + "text": " drmFormatModifier must be compatible with the parameters in VkImageCreateInfo and its pNext chain, as determined by querying VkPhysicalDeviceImageFormatInfo2 extended with VkPhysicalDeviceImageDrmFormatModifierInfoEXT" + }, + { + "vuid": "VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-drmFormatModifierPlaneCount-02265", + "text": " drmFormatModifierPlaneCount must be equal to the VkDrmFormatModifierPropertiesEXT::drmFormatModifierPlaneCount associated with VkImageCreateInfo::format and drmFormatModifier, as found by querying VkDrmFormatModifierPropertiesListEXT" + }, + { + "vuid": "VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-size-02267", + "text": " For each element of pPlaneLayouts, size must be 0" + }, + { + "vuid": "VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-arrayPitch-02268", + "text": " For each element of pPlaneLayouts, arrayPitch must be 0 if VkImageCreateInfo::arrayLayers is 1" + }, + { + "vuid": "VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-depthPitch-02269", + "text": " For each element of pPlaneLayouts, depthPitch must be 0 if VkImageCreateInfo::extent.depth is 1" + }, + { + "vuid": "VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-pPlaneLayouts-parameter", + "text": " If drmFormatModifierPlaneCount is not 0, pPlaneLayouts must be a valid pointer to an array of drmFormatModifierPlaneCount VkSubresourceLayout structures" + } + ] + }, + "vkGetImageSubresourceLayout": { + "!(VK_EXT_image_drm_format_modifier)": [ + { + "vuid": "VUID-vkGetImageSubresourceLayout-image-00996", + "text": " image must have been created with tiling equal to VK_IMAGE_TILING_LINEAR" + } + ], + "(VK_EXT_image_drm_format_modifier)": [ + { + "vuid": "VUID-vkGetImageSubresourceLayout-image-02270", + "text": " image must have been created with tiling equal to VK_IMAGE_TILING_LINEAR or VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-tiling-02271", + "text": " If the tiling of the image is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then the aspectMask member of pSubresource must be VK_IMAGE_ASPECT_MEMORY_PLANE{ibit}BIT_EXT and the index i must be less than the VkDrmFormatModifierPropertiesEXT::drmFormatModifierPlaneCount associated with the image’s format and VkImageDrmFormatModifierPropertiesEXT::drmFormatModifier" + } + ], + "core": [ + { + "vuid": "VUID-vkGetImageSubresourceLayout-aspectMask-00997", + "text": " The aspectMask member of pSubresource must only have a single bit set" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-mipLevel-01716", + "text": " The mipLevel member of pSubresource must be less than the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-arrayLayer-01717", + "text": " The arrayLayer member of pSubresource must be less than the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-format-04461", + "text": " If format is a color format, the aspectMask member of pSubresource must be VK_IMAGE_ASPECT_COLOR_BIT" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-format-04462", + "text": " If format has a depth component, the aspectMask member of pSubresource must contain VK_IMAGE_ASPECT_DEPTH_BIT" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-format-04463", + "text": " If format has a stencil component, the aspectMask member of pSubresource must contain VK_IMAGE_ASPECT_STENCIL_BIT" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-format-04464", + "text": " If format does not contain a stencil or depth component, the aspectMask member of pSubresource must not contain VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-image-parameter", + "text": " image must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-pSubresource-parameter", + "text": " pSubresource must be a valid pointer to a valid VkImageSubresource structure" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-pLayout-parameter", + "text": " pLayout must be a valid pointer to a VkSubresourceLayout structure" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-image-parent", + "text": " image must have been created, allocated, or retrieved from device" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkGetImageSubresourceLayout-format-01581", + "text": " If the tiling of the image is VK_IMAGE_TILING_LINEAR and its format is a multi-planar format with two planes, the aspectMask member of pSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT" + }, + { + "vuid": "VUID-vkGetImageSubresourceLayout-format-01582", + "text": " If the tiling of the image is VK_IMAGE_TILING_LINEAR and its format is a multi-planar format with three planes, the aspectMask member of pSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT" + } + ], + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkGetImageSubresourceLayout-image-01895", + "text": " If image was created with the VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID external memory handle type, then image must be bound to memory" + } + ] + }, + "VkImageSubresource": { + "core": [ + { + "vuid": "VUID-VkImageSubresource-aspectMask-parameter", + "text": " aspectMask must be a valid combination of VkImageAspectFlagBits values" + }, + { + "vuid": "VUID-VkImageSubresource-aspectMask-requiredbitmask", + "text": " aspectMask must not be 0" + } + ] + }, + "vkGetImageDrmFormatModifierPropertiesEXT": { + "(VK_EXT_image_drm_format_modifier)": [ + { + "vuid": "VUID-vkGetImageDrmFormatModifierPropertiesEXT-image-02272", + "text": " image must have been created with tiling equal to VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT" + }, + { + "vuid": "VUID-vkGetImageDrmFormatModifierPropertiesEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetImageDrmFormatModifierPropertiesEXT-image-parameter", + "text": " image must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkGetImageDrmFormatModifierPropertiesEXT-pProperties-parameter", + "text": " pProperties must be a valid pointer to a VkImageDrmFormatModifierPropertiesEXT structure" + }, + { + "vuid": "VUID-vkGetImageDrmFormatModifierPropertiesEXT-image-parent", + "text": " image must have been created, allocated, or retrieved from device" + } + ] + }, + "VkImageDrmFormatModifierPropertiesEXT": { + "(VK_EXT_image_drm_format_modifier)": [ + { + "vuid": "VUID-VkImageDrmFormatModifierPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT" + }, + { + "vuid": "VUID-VkImageDrmFormatModifierPropertiesEXT-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkDestroyImage": { + "core": [ + { + "vuid": "VUID-vkDestroyImage-image-01000", + "text": " All submitted commands that refer to image, either directly or via a VkImageView, must have completed execution" + }, + { + "vuid": "VUID-vkDestroyImage-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyImage-image-parameter", + "text": " If image is not VK_NULL_HANDLE, image must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkDestroyImage-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyImage-image-parent", + "text": " If image is a valid handle, it must have been created, allocated, or retrieved from device" + } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyImage-image-01001", + "text": " If VkAllocationCallbacks were provided when image was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyImage-image-01002", + "text": " If no VkAllocationCallbacks were provided when image was created, pAllocator must be NULL" + } + ], + "(VK_KHR_swapchain)": [ + { + "vuid": "VUID-vkDestroyImage-image-04882", + "text": " image must not have been acquired from vkGetSwapchainImagesKHR" + } + ] + }, + "vkCreateImageView": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateImageView-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + }, + { + "vuid": "VUID-vkCreateImageView-subresourceRange-05063", + "text": " If VkImageViewCreateInfo::subresourceRange.layerCount is greater than 1, the number of image views with more than one array layer currently allocated from device plus 1 must be less than or equal to the total number of image views requested via VkDeviceObjectReservationCreateInfo::layeredImageViewRequestCount specified when device was created" + } + ], + "core": [ + { + "vuid": "VUID-vkCreateImageView-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateImageView-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkImageViewCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateImageView-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateImageView-pView-parameter", + "text": " pView must be a valid pointer to a VkImageView handle" + } + ] + }, + "VkImageViewCreateInfo": { + "core": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-01003", + "text": " If image was not created with VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT then viewType must not be VK_IMAGE_VIEW_TYPE_CUBE or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-viewType-01004", + "text": " If the image cube map arrays feature is not enabled, viewType must not be VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-04441", + "text": " image must have been created with a usage value containing at least one of the usages defined in the valid image usage list for image views" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-None-02273", + "text": " The format features of the resultant image view must contain at least one bit" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-usage-02274", + "text": " If usage contains VK_IMAGE_USAGE_SAMPLED_BIT, then the format features of the resultant image view must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-usage-02275", + "text": " If usage contains VK_IMAGE_USAGE_STORAGE_BIT, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-usage-02276", + "text": " If usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, then the image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-usage-02277", + "text": " If usage contains VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, then the image view’s format features must contain VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-usage-02652", + "text": " If usage contains VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, then the image view’s format features must contain at least one of VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT or VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-01478", + "text": " subresourceRange.baseMipLevel must be less than the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-01718", + "text": " If subresourceRange.levelCount is not VK_REMAINING_MIP_LEVELS, subresourceRange.baseMipLevel + subresourceRange.levelCount must be less than or equal to the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01020", + "text": " If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-subResourceRange-01021", + "text": " viewType must be compatible with the type of image as shown in the view type compatibility table" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-imageViewType-04973", + "text": " If viewType is VK_IMAGE_VIEW_TYPE_1D, VK_IMAGE_VIEW_TYPE_2D, or VK_IMAGE_VIEW_TYPE_3D; and subresourceRange.layerCount is not VK_REMAINING_ARRAY_LAYERS, then subresourceRange.layerCount must be 1" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-imageViewType-04974", + "text": " If viewType is VK_IMAGE_VIEW_TYPE_1D, VK_IMAGE_VIEW_TYPE_2D, or VK_IMAGE_VIEW_TYPE_3D; and subresourceRange.layerCount is VK_REMAINING_ARRAY_LAYERS, then the remaining number of layers must be 1" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-viewType-02960", + "text": " If viewType is VK_IMAGE_VIEW_TYPE_CUBE and subresourceRange.layerCount is not VK_REMAINING_ARRAY_LAYERS, subresourceRange.layerCount must be 6" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-viewType-02961", + "text": " If viewType is VK_IMAGE_VIEW_TYPE_CUBE_ARRAY and subresourceRange.layerCount is not VK_REMAINING_ARRAY_LAYERS, subresourceRange.layerCount must be a multiple of 6" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-viewType-02962", + "text": " If viewType is VK_IMAGE_VIEW_TYPE_CUBE and subresourceRange.layerCount is VK_REMAINING_ARRAY_LAYERS, the remaining number of layers must be 6" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-viewType-02963", + "text": " If viewType is VK_IMAGE_VIEW_TYPE_CUBE_ARRAY and subresourceRange.layerCount is VK_REMAINING_ARRAY_LAYERS, the remaining number of layers must be a multiple of 6" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkImageViewASTCDecodeModeEXT, VkImageViewUsageCreateInfo, or VkSamplerYcbcrConversionInfo" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-parameter", + "text": " image must be a valid VkImage handle" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-viewType-parameter", + "text": " viewType must be a valid VkImageViewType value" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-format-parameter", + "text": " format must be a valid VkFormat value" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-components-parameter", + "text": " components must be a valid VkComponentMapping structure" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-parameter", + "text": " subresourceRange must be a valid VkImageSubresourceRange structure" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-01005", + "text": " If image was created with VK_IMAGE_TYPE_3D but without VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set then viewType must not be VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-04970", + "text": " If image was created with VK_IMAGE_TYPE_3D and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY then subresourceRange.levelCount must be 1" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-04972", + "text": " If image was created with a samples value not equal to VK_SAMPLE_COUNT_1_BIT then viewType must be either VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01482", + "text": " If image is not a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, or viewType is not VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange.baseArrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-01483", + "text": " If subresourceRange.layerCount is not VK_REMAINING_ARRAY_LAYERS, image is not a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, or viewType is not VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange.layerCount must be non-zero and subresourceRange.baseArrayLayer + subresourceRange.layerCount must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-02724", + "text": " If image is a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange.baseArrayLayer must be less than the depth computed from baseMipLevel and extent.depth specified in VkImageCreateInfo when image was created, according to the formula defined in Image Miplevel Sizing" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-02725", + "text": " If subresourceRange.layerCount is not VK_REMAINING_ARRAY_LAYERS, image is a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange.layerCount must be non-zero and subresourceRange.baseArrayLayer + subresourceRange.layerCount must be less than or equal to the depth computed from baseMipLevel and extent.depth specified in VkImageCreateInfo when image was created, according to the formula defined in Image Miplevel Sizing" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance1)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-04971", + "text": " If image was created with VK_IMAGE_TYPE_3D and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY then flags must not contain any of VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, and VK_IMAGE_CREATE_SPARSE_ALIASED_BIT" + } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-02571", + "text": " If image was created with usage containing VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, subresourceRange.levelCount must be 1" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-flags-02572", + "text": " If dynamic fragment density map feature is not enabled, flags must not contain VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-flags-04116", + "text": " If flags does not contain VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT and image was created with usage containing VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, its flags must not contain any of VK_IMAGE_CREATE_PROTECTED_BIT, VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT" + } + ], + "!(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-01480", + "text": " subresourceRange.baseArrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-01719", + "text": " If subresourceRange.layerCount is not VK_REMAINING_ARRAY_LAYERS, subresourceRange.baseArrayLayer + subresourceRange.layerCount must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created" + } + ], + "!(VK_VERSION_1_1,VK_KHR_maintenance2)+!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-01018", + "text": " If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, format must be compatible with the format used to create image, as defined in Format Compatibility Classes" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance2)+!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-01759", + "text": " If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, but without the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, format must be compatible with the format used to create image, as defined in Format Compatibility Classes" + } + ], + "!(VK_VERSION_1_1,VK_KHR_maintenance2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-01760", + "text": " If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, and if the format of the image is not a multi-planar format, format must be compatible with the format used to create image, as defined in Format Compatibility Classes" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-01761", + "text": " If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, but without the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, and if the format of the image is not a multi-planar format, format must be compatible with the format used to create image, as defined in Format Compatibility Classes" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-01583", + "text": " If image was created with the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, format must be compatible with, or must be an uncompressed format that is size-compatible with, the format used to create image" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01584", + "text": " If image was created with the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, the levelCount and layerCount members of subresourceRange must both be 1" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-04739", + "text": " If image was created with the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag and format is a non-compressed format, viewType must not be VK_IMAGE_VIEW_TYPE_3D" + } + ], + "(VK_VERSION_1_2,VK_KHR_image_format_list)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-pNext-01585", + "text": " If a VkImageFormatListCreateInfo structure was included in the pNext chain of the VkImageCreateInfo structure used when creating image and VkImageFormatListCreateInfo::viewFormatCount is not zero then format must be one of the formats in VkImageFormatListCreateInfo::pViewFormats" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-01586", + "text": " If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, if the format of the image is a multi-planar format, and if subresourceRange.aspectMask is one of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT, then format must be compatible with the VkFormat for the plane of the image format indicated by subresourceRange.aspectMask, as defined in Compatible formats of planes of multi-planar formats" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-01762", + "text": " If image was not created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, or if the format of the image is a multi-planar format and if subresourceRange.aspectMask is VK_IMAGE_ASPECT_COLOR_BIT, format must be identical to the format used to create image" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-format-06415", + "text": " If the image format is one of the formats that require a sampler Y’CBCR conversion, then the pNext chain must include a VkSamplerYcbcrConversionInfo structure with a conversion value other than VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-format-04714", + "text": " If format has a _422 or _420 suffix then image must have been created with a width that is a multiple of 2" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-format-04715", + "text": " If format has a _420 suffix then image must have been created with a height that is a multiple of 2" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-pNext-01970", + "text": " If the pNext chain includes a VkSamplerYcbcrConversionInfo structure with a conversion value other than VK_NULL_HANDLE, all members of components must have the identity swizzle" + } + ], + "!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-01019", + "text": " If image was not created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, format must be identical to the format used to create image" + } + ], + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-02399", + "text": " If image has an external format, format must be VK_FORMAT_UNDEFINED" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-02400", + "text": " If image has an external format, the pNext chain must include a VkSamplerYcbcrConversionInfo structure with a conversion object created with the same external format as image" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-02401", + "text": " If image has an external format, all members of components must be the identity swizzle" + } + ], + "(VK_KHR_fragment_shading_rate,VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-02086", + "text": " If image was created with usage containing VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, viewType must be VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY" + } + ], + "(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-02087", + "text": " If the shadingRateImage feature is enabled, and If image was created with usage containing VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, format must be VK_FORMAT_R8_UINT" + } + ], + "(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-usage-04550", + "text": " If the attachmentFragmentShadingRate feature is enabled, and the usage for the image view includes VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, then the image view’s format features must contain VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-usage-04551", + "text": " If the attachmentFragmentShadingRate feature is enabled, the usage for the image view includes VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, and layeredShadingRateAttachments is VK_FALSE, subresourceRange.layerCount must be 1" + } + ], + "(VK_EXT_fragment_density_map)+(VK_EXT_fragment_density_map2)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-flags-03567", + "text": " If deferred fragment density map feature is not enabled, flags must not contain VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-flags-03568", + "text": " If flags contains VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT, flags must not contain VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-image-03569", + "text": " If image was created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT and usage containing VK_IMAGE_USAGE_SAMPLED_BIT, subresourceRange.layerCount must be less than or equal to VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::maxSubsampledArrayLayers" + } + ], + "(VK_EXT_fragment_density_map)+(VK_HUAWEI_invocation_mask)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-invocationMask-04993", + "text": " If the invocationMask feature is enabled, and if image was created with usage containing VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI, format must be VK_FORMAT_R8_UINT" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance2)+!(VK_VERSION_1_2+VK_EXT_separate_stencil_usage)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-pNext-02661", + "text": " If the pNext chain includes a VkImageViewUsageCreateInfo structure, its usage member must not include any bits that were not set in the usage member of the VkImageCreateInfo structure used to create image" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance2)+(VK_VERSION_1_2,VK_EXT_separate_stencil_usage)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-pNext-02662", + "text": " If the pNext chain includes a VkImageViewUsageCreateInfo structure, and image was not created with a VkImageStencilUsageCreateInfo structure included in the pNext chain of VkImageCreateInfo, its usage member must not include any bits that were not set in the usage member of the VkImageCreateInfo structure used to create image" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-pNext-02663", + "text": " If the pNext chain includes a VkImageViewUsageCreateInfo structure, image was created with a VkImageStencilUsageCreateInfo structure included in the pNext chain of VkImageCreateInfo, and subresourceRange.aspectMask includes VK_IMAGE_ASPECT_STENCIL_BIT, the usage member of the VkImageViewUsageCreateInfo structure must not include any bits that were not set in the usage member of the VkImageStencilUsageCreateInfo structure used to create image" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-pNext-02664", + "text": " If the pNext chain includes a VkImageViewUsageCreateInfo structure, image was created with a VkImageStencilUsageCreateInfo structure included in the pNext chain of VkImageCreateInfo, and subresourceRange.aspectMask includes bits other than VK_IMAGE_ASPECT_STENCIL_BIT, the usage member of the VkImageViewUsageCreateInfo structure must not include any bits that were not set in the usage member of the VkImageCreateInfo structure used to create image" + } + ], + "(VK_KHR_portability_subset)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-imageViewFormatSwizzle-04465", + "text": " If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::imageViewFormatSwizzle is VK_FALSE, all elements of components must have the identity swizzle" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-imageViewFormatReinterpretation-04466", + "text": " If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::imageViewFormatReinterpretation is VK_FALSE, the VkFormat in format must not contain a different number of components, or a different number of bits in each component, than the format of the VkImage in image" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-05064", + "text": " subresourceRange.levelCount must be less than or equal to VkDeviceObjectReservationCreateInfo::maxImageViewMipLevels" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-05065", + "text": " subresourceRange.layerCount must be less than or equal to VkDeviceObjectReservationCreateInfo::maxImageViewArrayLayers" + }, + { + "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-05066", + "text": " If subresourceRange.layerCount is greater than 1, subresourceRange.levelCount must be less than or equal to VkDeviceObjectReservationCreateInfo::maxLayeredImageViewMipLevels" + } + ], + "(VK_KHR_video_decode_queue)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-04817", + "text": " If image was created with usage containing VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR, VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR, VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR, then the viewType must be VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY and all members of components must have the identity swizzle" + } + ], + "(VK_KHR_video_encode_queue)": [ + { + "vuid": "VUID-VkImageViewCreateInfo-image-04818", + "text": " If image was created with usage containing VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR, VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR, VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR, then the viewType must be VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY and all members of components must have the identity swizzle" + } + ] + }, + "VkImageViewUsageCreateInfo": { + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkImageViewUsageCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO" + }, + { + "vuid": "VUID-VkImageViewUsageCreateInfo-usage-parameter", + "text": " usage must be a valid combination of VkImageUsageFlagBits values" + }, + { + "vuid": "VUID-VkImageViewUsageCreateInfo-usage-requiredbitmask", + "text": " usage must not be 0" + } + ] + }, + "VkImageSubresourceRange": { + "core": [ + { + "vuid": "VUID-VkImageSubresourceRange-levelCount-01720", + "text": " If levelCount is not VK_REMAINING_MIP_LEVELS, it must be greater than 0" + }, + { + "vuid": "VUID-VkImageSubresourceRange-layerCount-01721", + "text": " If layerCount is not VK_REMAINING_ARRAY_LAYERS, it must be greater than 0" + }, + { + "vuid": "VUID-VkImageSubresourceRange-aspectMask-parameter", + "text": " aspectMask must be a valid combination of VkImageAspectFlagBits values" + }, + { + "vuid": "VUID-VkImageSubresourceRange-aspectMask-requiredbitmask", + "text": " aspectMask must not be 0" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageSubresourceRange-aspectMask-01670", + "text": " If aspectMask includes VK_IMAGE_ASPECT_COLOR_BIT, then it must not include any of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT" + } + ], + "(VK_EXT_image_drm_format_modifier)": [ + { + "vuid": "VUID-VkImageSubresourceRange-aspectMask-02278", + "text": " aspectMask must not include VK_IMAGE_ASPECT_MEMORY_PLANE{ibit}BIT_EXT for any index i" + } + ] + }, + "VkComponentMapping": { + "core": [ + { + "vuid": "VUID-VkComponentMapping-r-parameter", + "text": " r must be a valid VkComponentSwizzle value" + }, + { + "vuid": "VUID-VkComponentMapping-g-parameter", + "text": " g must be a valid VkComponentSwizzle value" + }, + { + "vuid": "VUID-VkComponentMapping-b-parameter", + "text": " b must be a valid VkComponentSwizzle value" + }, + { + "vuid": "VUID-VkComponentMapping-a-parameter", + "text": " a must be a valid VkComponentSwizzle value" + } + ] + }, + "VkImageViewASTCDecodeModeEXT": { + "(VK_EXT_astc_decode_mode)": [ + { + "vuid": "VUID-VkImageViewASTCDecodeModeEXT-decodeMode-02230", + "text": " decodeMode must be one of VK_FORMAT_R16G16B16A16_SFLOAT, VK_FORMAT_R8G8B8A8_UNORM, or VK_FORMAT_E5B9G9R9_UFLOAT_PACK32" + }, + { + "vuid": "VUID-VkImageViewASTCDecodeModeEXT-decodeMode-02231", + "text": " If the decodeModeSharedExponent feature is not enabled, decodeMode must not be VK_FORMAT_E5B9G9R9_UFLOAT_PACK32" + }, + { + "vuid": "VUID-VkImageViewASTCDecodeModeEXT-decodeMode-02232", + "text": " If decodeMode is VK_FORMAT_R8G8B8A8_UNORM the image view must not include blocks using any of the ASTC HDR modes" + }, + { + "vuid": "VUID-VkImageViewASTCDecodeModeEXT-format-04084", + "text": " format of the image view must be one of the ASTC Compressed Image Formats" + }, + { + "vuid": "VUID-VkImageViewASTCDecodeModeEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT" + }, + { + "vuid": "VUID-VkImageViewASTCDecodeModeEXT-decodeMode-parameter", + "text": " decodeMode must be a valid VkFormat value" + } + ] + }, + "vkDestroyImageView": { + "core": [ + { + "vuid": "VUID-vkDestroyImageView-imageView-01026", + "text": " All submitted commands that refer to imageView must have completed execution" + }, + { + "vuid": "VUID-vkDestroyImageView-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyImageView-imageView-parameter", + "text": " If imageView is not VK_NULL_HANDLE, imageView must be a valid VkImageView handle" + }, + { + "vuid": "VUID-vkDestroyImageView-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyImageView-imageView-parent", + "text": " If imageView is a valid handle, it must have been created, allocated, or retrieved from device" + } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyImageView-imageView-01027", + "text": " If VkAllocationCallbacks were provided when imageView was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyImageView-imageView-01028", + "text": " If no VkAllocationCallbacks were provided when imageView was created, pAllocator must be NULL" + } + ] + }, + "VkImageViewHandleInfoNVX": { + "(VK_NVX_image_view_handle)": [ + { + "vuid": "VUID-VkImageViewHandleInfoNVX-descriptorType-02654", + "text": " descriptorType must be VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER" + }, + { + "vuid": "VUID-VkImageViewHandleInfoNVX-sampler-02655", + "text": " sampler must be a valid VkSampler if descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER" + }, + { + "vuid": "VUID-VkImageViewHandleInfoNVX-imageView-02656", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, the image that imageView was created from must have been created with the VK_IMAGE_USAGE_SAMPLED_BIT usage bit set" + }, + { + "vuid": "VUID-VkImageViewHandleInfoNVX-imageView-02657", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, the image that imageView was created from must have been created with the VK_IMAGE_USAGE_STORAGE_BIT usage bit set" + } + ] + }, + "VkImageViewMinLodCreateInfoEXT": { + "(VK_EXT_image_view_min_lod)": [ + { + "vuid": "VUID-VkImageViewMinLodCreateInfoEXT-minLod-06455", + "text": " If the minLod feature is not enabled, minLod must be 0.0." + }, + { + "vuid": "VUID-VkImageViewMinLodCreateInfoEXT-minLod-06456", + "text": " minLod must be less or equal to the index of the last mipmap level accessible to the view." + } + ] + }, + "VkAccelerationStructureCreateInfoNV": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkAccelerationStructureCreateInfoNV-compactedSize-02421", + "text": " If compactedSize is not 0 then both info.geometryCount and info.instanceCount must be 0" + } + ] + }, + "VkAccelerationStructureInfoNV": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkAccelerationStructureInfoNV-geometryCount-02422", + "text": " geometryCount must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxGeometryCount" + }, + { + "vuid": "VUID-VkAccelerationStructureInfoNV-instanceCount-02423", + "text": " instanceCount must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxInstanceCount" + }, + { + "vuid": "VUID-VkAccelerationStructureInfoNV-maxTriangleCount-02424", + "text": " The total number of triangles in all geometries must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxTriangleCount" + }, + { + "vuid": "VUID-VkAccelerationStructureInfoNV-type-02425", + "text": " If type is VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV then geometryCount must be 0" + }, + { + "vuid": "VUID-VkAccelerationStructureInfoNV-type-02426", + "text": " If type is VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV then instanceCount must be 0" + }, + { + "vuid": "VUID-VkAccelerationStructureInfoNV-type-02786", + "text": " If type is VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV then the geometryType member of each geometry in pGeometries must be the same" + }, + { + "vuid": "VUID-VkAccelerationStructureInfoNV-flags-02592", + "text": " If flags has the VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV bit set, then it must not have the VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV bit set" + }, + { + "vuid": "VUID-VkAccelerationStructureInfoNV-scratch-02781", + "text": " scratch must have been created with VK_BUFFER_USAGE_RAY_TRACING_BIT_NV usage flag" + }, + { + "vuid": "VUID-VkAccelerationStructureInfoNV-instanceData-02782", + "text": " If instanceData is not VK_NULL_HANDLE, instanceData must have been created with VK_BUFFER_USAGE_RAY_TRACING_BIT_NV usage flag" + } + ], + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_NV_ray_tracing)+(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-VkAccelerationStructureInfoNV-type-04623", + "text": " type must not be VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR" + } + ] + }, + "vkCreateAccelerationStructureKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCreateAccelerationStructureKHR-accelerationStructure-03611", + "text": " The accelerationStructure feature must be enabled" + }, + { + "vuid": "VUID-vkCreateAccelerationStructureKHR-deviceAddress-03488", + "text": " If VkAccelerationStructureCreateInfoKHR::deviceAddress is not zero, the accelerationStructureCaptureReplay feature must be enabled" + }, + { + "vuid": "VUID-vkCreateAccelerationStructureKHR-device-03489", + "text": " If device was created with multiple physical devices, then the bufferDeviceAddressMultiDevice feature must be enabled" + } + ] + }, + "VkAccelerationStructureCreateInfoKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-VkAccelerationStructureCreateInfoKHR-deviceAddress-03612", + "text": " If deviceAddress is not zero, createFlags must include VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR" + }, + { + "vuid": "VUID-VkAccelerationStructureCreateInfoKHR-createFlags-03613", + "text": " If createFlags includes VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR, VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureCaptureReplay must be VK_TRUE" + }, + { + "vuid": "VUID-VkAccelerationStructureCreateInfoKHR-buffer-03614", + "text": " buffer must have been created with a usage value containing VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR" + }, + { + "vuid": "VUID-VkAccelerationStructureCreateInfoKHR-buffer-03615", + "text": " buffer must not have been created with VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT" + }, + { + "vuid": "VUID-VkAccelerationStructureCreateInfoKHR-offset-03616", + "text": " The sum of offset and size must be less than the size of buffer" + }, + { + "vuid": "VUID-VkAccelerationStructureCreateInfoKHR-offset-03734", + "text": " offset must be a multiple of 256 bytes" + } + ], + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)+(VK_NV_ray_tracing_motion_blur)": [ + { + "vuid": "VUID-VkAccelerationStructureCreateInfoKHR-flags-04954", + "text": " If VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV is set in flags and type is VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, one member of the pNext chain must be a pointer to a valid instance of VkAccelerationStructureMotionInfoNV" + }, + { + "vuid": "VUID-VkAccelerationStructureCreateInfoKHR-flags-04955", + "text": " If any geometry includes VkAccelerationStructureGeometryMotionTrianglesDataNV then flags must contain VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV" + } + ] + }, + "vkGetAccelerationStructureBuildSizesKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkGetAccelerationStructureBuildSizesKHR-rayTracingPipeline-03617", + "text": " The rayTracingPipeline or rayQuery feature must be enabled" + }, + { + "vuid": "VUID-vkGetAccelerationStructureBuildSizesKHR-device-03618", + "text": " If device was created with multiple physical devices, then the bufferDeviceAddressMultiDevice feature must be enabled" + }, + { + "vuid": "VUID-vkGetAccelerationStructureBuildSizesKHR-pBuildInfo-03619", + "text": " If pBuildInfo->geometryCount is not 0, pMaxPrimitiveCounts must be a valid pointer to an array of pBuildInfo->geometryCount uint32_t values" + }, + { + "vuid": "VUID-vkGetAccelerationStructureBuildSizesKHR-pBuildInfo-03785", + "text": " If pBuildInfo->pGeometries or pBuildInfo->ppGeometries has a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR, each pMaxPrimitiveCounts[i] must be less than or equal to VkPhysicalDeviceAccelerationStructurePropertiesKHR::maxInstanceCount" + } + ] + }, + "VkGeometryNV": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkGeometryNV-geometryType-03503", + "text": " geometryType must be VK_GEOMETRY_TYPE_TRIANGLES_NV or VK_GEOMETRY_TYPE_AABBS_NV" + } + ] + }, + "VkGeometryTrianglesNV": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkGeometryTrianglesNV-vertexOffset-02428", + "text": " vertexOffset must be less than the size of vertexData" + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-vertexOffset-02429", + "text": " vertexOffset must be a multiple of the component size of vertexFormat" + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-vertexFormat-02430", + "text": " vertexFormat must be one of VK_FORMAT_R32G32B32_SFLOAT, VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_R16G16B16_SFLOAT, VK_FORMAT_R16G16_SFLOAT, VK_FORMAT_R16G16_SNORM, or VK_FORMAT_R16G16B16_SNORM" + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-vertexStride-03818", + "text": " vertexStride must be less than or equal to 232-1" + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-indexOffset-02431", + "text": " indexOffset must be less than the size of indexData" + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-indexOffset-02432", + "text": " indexOffset must be a multiple of the element size of indexType" + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-indexType-02433", + "text": " indexType must be VK_INDEX_TYPE_UINT16, VK_INDEX_TYPE_UINT32, or VK_INDEX_TYPE_NONE_NV" + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-indexData-02434", + "text": " indexData must be VK_NULL_HANDLE if indexType is VK_INDEX_TYPE_NONE_NV" + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-indexData-02435", + "text": " indexData must be a valid VkBuffer handle if indexType is not VK_INDEX_TYPE_NONE_NV" + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-indexCount-02436", + "text": " indexCount must be 0 if indexType is VK_INDEX_TYPE_NONE_NV" + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-transformOffset-02437", + "text": " transformOffset must be less than the size of transformData" + }, + { + "vuid": "VUID-VkGeometryTrianglesNV-transformOffset-02438", + "text": " transformOffset must be a multiple of 16" + } + ] + }, + "VkGeometryAABBNV": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkGeometryAABBNV-offset-02439", + "text": " offset must be less than the size of aabbData" + }, + { + "vuid": "VUID-VkGeometryAABBNV-offset-02440", + "text": " offset must be a multiple of 8" + }, + { + "vuid": "VUID-VkGeometryAABBNV-stride-02441", + "text": " stride must be a multiple of 8" + } + ] + }, + "vkDestroyAccelerationStructureKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkDestroyAccelerationStructureKHR-accelerationStructure-02442", + "text": " All submitted commands that refer to accelerationStructure must have completed execution" + } + ], + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyAccelerationStructureKHR-accelerationStructure-02443", + "text": " If VkAllocationCallbacks were provided when accelerationStructure was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyAccelerationStructureKHR-accelerationStructure-02444", + "text": " If no VkAllocationCallbacks were provided when accelerationStructure was created, pAllocator must be NULL" + } + ] + }, + "vkDestroyAccelerationStructureNV": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-vkDestroyAccelerationStructureNV-accelerationStructure-03752", + "text": " All submitted commands that refer to accelerationStructure must have completed execution" + } + ], + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_NV_ray_tracing)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyAccelerationStructureNV-accelerationStructure-03753", + "text": " If VkAllocationCallbacks were provided when accelerationStructure was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyAccelerationStructureNV-accelerationStructure-03754", + "text": " If no VkAllocationCallbacks were provided when accelerationStructure was created, pAllocator must be NULL" + } + ] + }, + "VkBindAccelerationStructureMemoryInfoNV": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNV-accelerationStructure-03620", + "text": " accelerationStructure must not already be backed by a memory object" + }, + { + "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNV-memoryOffset-03621", + "text": " memoryOffset must be less than the size of memory" + }, + { + "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNV-memory-03622", + "text": " memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetAccelerationStructureMemoryRequirementsNV with accelerationStructure and type of VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV" + }, + { + "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNV-memoryOffset-03623", + "text": " memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetAccelerationStructureMemoryRequirementsNV with accelerationStructure and type of VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV" + }, + { + "vuid": "VUID-VkBindAccelerationStructureMemoryInfoNV-size-03624", + "text": " The size member of the VkMemoryRequirements structure returned from a call to vkGetAccelerationStructureMemoryRequirementsNV with accelerationStructure and type of VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV must be less than or equal to the size of memory minus memoryOffset" + } + ] + }, + "vkGetAccelerationStructureHandleNV": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-vkGetAccelerationStructureHandleNV-dataSize-02240", + "text": " dataSize must be large enough to contain the result of the query, as described above" + }, + { + "vuid": "VUID-vkGetAccelerationStructureHandleNV-accelerationStructure-02787", + "text": " accelerationStructure must be bound completely and contiguously to a single VkDeviceMemory object via vkBindAccelerationStructureMemoryNV" + } + ] + }, + "vkGetAccelerationStructureDeviceAddressKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkGetAccelerationStructureDeviceAddressKHR-device-03504", + "text": " If device was created with multiple physical devices, then the bufferDeviceAddressMultiDevice feature must be enabled" + } + ] + }, + "vkGetBufferMemoryRequirements": { + "core": [ + { + "vuid": "VUID-vkGetBufferMemoryRequirements-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetBufferMemoryRequirements-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkGetBufferMemoryRequirements-pMemoryRequirements-parameter", + "text": " pMemoryRequirements must be a valid pointer to a VkMemoryRequirements structure" + }, + { + "vuid": "VUID-vkGetBufferMemoryRequirements-buffer-parent", + "text": " buffer must have been created, allocated, or retrieved from device" + } + ] + }, + "vkGetImageMemoryRequirements": { + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkGetImageMemoryRequirements-image-01588", + "text": " image must not have been created with the VK_IMAGE_CREATE_DISJOINT_BIT flag set" + } + ], + "(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkGetImageMemoryRequirements-image-04004", + "text": " If image was created with the VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID external memory handle type, then image must be bound to memory" + } + ], + "core": [ + { + "vuid": "VUID-vkGetImageMemoryRequirements-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetImageMemoryRequirements-image-parameter", + "text": " image must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkGetImageMemoryRequirements-pMemoryRequirements-parameter", + "text": " pMemoryRequirements must be a valid pointer to a VkMemoryRequirements structure" + }, + { + "vuid": "VUID-vkGetImageMemoryRequirements-image-parent", + "text": " image must have been created, allocated, or retrieved from device" + } + ] + }, + "vkGetBufferMemoryRequirements2": { + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ + { + "vuid": "VUID-vkGetBufferMemoryRequirements2-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetBufferMemoryRequirements2-pInfo-parameter", + "text": " pInfo must be a valid pointer to a valid VkBufferMemoryRequirementsInfo2 structure" + }, + { + "vuid": "VUID-vkGetBufferMemoryRequirements2-pMemoryRequirements-parameter", + "text": " pMemoryRequirements must be a valid pointer to a VkMemoryRequirements2 structure" + } + ] + }, + "VkBufferMemoryRequirementsInfo2": { + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ + { + "vuid": "VUID-VkBufferMemoryRequirementsInfo2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2" + }, + { + "vuid": "VUID-VkBufferMemoryRequirementsInfo2-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkBufferMemoryRequirementsInfo2-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + } + ] + }, + "vkGetImageMemoryRequirements2": { + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ + { + "vuid": "VUID-vkGetImageMemoryRequirements2-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetImageMemoryRequirements2-pInfo-parameter", + "text": " pInfo must be a valid pointer to a valid VkImageMemoryRequirementsInfo2 structure" + }, + { + "vuid": "VUID-vkGetImageMemoryRequirements2-pMemoryRequirements-parameter", + "text": " pMemoryRequirements must be a valid pointer to a VkMemoryRequirements2 structure" + } + ] + }, + "VkImageMemoryRequirementsInfo2": { + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageMemoryRequirementsInfo2-image-01589", + "text": " If image was created with a multi-planar format and the VK_IMAGE_CREATE_DISJOINT_BIT flag, there must be a VkImagePlaneMemoryRequirementsInfo included in the pNext chain of the VkImageMemoryRequirementsInfo2 structure" + }, + { + "vuid": "VUID-VkImageMemoryRequirementsInfo2-image-01590", + "text": " If image was not created with the VK_IMAGE_CREATE_DISJOINT_BIT flag, there must not be a VkImagePlaneMemoryRequirementsInfo included in the pNext chain of the VkImageMemoryRequirementsInfo2 structure" + } + ], + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_image_drm_format_modifier)": [ + { + "vuid": "VUID-VkImageMemoryRequirementsInfo2-image-02279", + "text": " If image was created with VK_IMAGE_CREATE_DISJOINT_BIT and with VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then there must be a VkImagePlaneMemoryRequirementsInfo included in the pNext chain of the VkImageMemoryRequirementsInfo2 structure" + }, + { + "vuid": "VUID-VkImageMemoryRequirementsInfo2-image-02280", + "text": " If image was created with a single-plane format and with any tiling other than VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then there must not be a VkImagePlaneMemoryRequirementsInfo included in the pNext chain of the VkImageMemoryRequirementsInfo2 structure" + } + ], + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_image_drm_format_modifier)": [ + { + "vuid": "VUID-VkImageMemoryRequirementsInfo2-image-01591", + "text": " If image was created with a single-plane format, there must not be a VkImagePlaneMemoryRequirementsInfo included in the pNext chain of the VkImageMemoryRequirementsInfo2 structure" + } + ], + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkImageMemoryRequirementsInfo2-image-01897", + "text": " If image was created with the VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID external memory handle type, then image must be bound to memory" + } + ], + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ + { + "vuid": "VUID-VkImageMemoryRequirementsInfo2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2" + }, + { + "vuid": "VUID-VkImageMemoryRequirementsInfo2-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkImagePlaneMemoryRequirementsInfo" + }, + { + "vuid": "VUID-VkImageMemoryRequirementsInfo2-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkImageMemoryRequirementsInfo2-image-parameter", + "text": " image must be a valid VkImage handle" + } + ] + }, + "VkDeviceImageMemoryRequirementsKHR": { + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-VkDeviceImageMemoryRequirementsKHR-pCreateInfo-06416", + "text": " The pCreateInfo::pNext chain must not contain a VkImageSwapchainCreateInfoKHR structure" + }, + { + "vuid": "VUID-VkDeviceImageMemoryRequirementsKHR-pCreateInfo-06417", + "text": " If pCreateInfo::flags has VK_IMAGE_CREATE_DISJOINT_BIT set then planeAspect must not be VK_IMAGE_ASPECT_NONE_KHR" + }, + { + "vuid": "VUID-VkDeviceImageMemoryRequirementsKHR-pCreateInfo-06419", + "text": " If pCreateInfo::flags has VK_IMAGE_CREATE_DISJOINT_BIT set and if the pCreateInfo::tiling is VK_IMAGE_TILING_LINEAR or VK_IMAGE_TILING_OPTIMAL, then planeAspect must be a single valid format plane for the image (that is, for a two-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT, and for a three-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT)" + } + ], + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_KHR_maintenance4)+(VK_EXT_image_drm_format_modifier)": [ + { + "vuid": "VUID-VkDeviceImageMemoryRequirementsKHR-pCreateInfo-06418", + "text": " If pCreateInfo::flags has VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT set then planeAspect must not be VK_IMAGE_ASPECT_NONE_KHR" + }, + { + "vuid": "VUID-VkDeviceImageMemoryRequirementsKHR-pCreateInfo-06420", + "text": " If pCreateInfo::flags has VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT set and the pCreateInfo::tiling is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then planeAspect must be a single valid memory plane for the image (that is, aspectMask must specify a plane index that is less than the VkDrmFormatModifierPropertiesEXT::drmFormatModifierPlaneCount associated with the image’s format and VkImageDrmFormatModifierPropertiesEXT::drmFormatModifier)" + } + ] + }, + "VkImagePlaneMemoryRequirementsInfo": { + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-02281", + "text": " If the image’s tiling is VK_IMAGE_TILING_LINEAR or VK_IMAGE_TILING_OPTIMAL, then planeAspect must be a single valid format plane for the image (that is, for a two-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT, and for a three-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT)" + }, + { + "vuid": "VUID-VkImagePlaneMemoryRequirementsInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO" + }, + { + "vuid": "VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-parameter", + "text": " planeAspect must be a valid VkImageAspectFlagBits value" + } + ], + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_image_drm_format_modifier)": [ + { + "vuid": "VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-02282", + "text": " If the image’s tiling is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then planeAspect must be a single valid memory plane for the image (that is, aspectMask must specify a plane index that is less than the VkDrmFormatModifierPropertiesEXT::drmFormatModifierPlaneCount associated with the image’s format and VkImageDrmFormatModifierPropertiesEXT::drmFormatModifier)" + } + ] + }, + "VkMemoryRequirements2": { + "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)": [ + { + "vuid": "VUID-VkMemoryRequirements2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2" + }, + { + "vuid": "VUID-VkMemoryRequirements2-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkMemoryDedicatedRequirements" + }, + { + "vuid": "VUID-VkMemoryRequirements2-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + } + ] + }, + "VkMemoryDedicatedRequirements": { + "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + { + "vuid": "VUID-VkMemoryDedicatedRequirements-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS" + } + ] + }, + "vkBindBufferMemory": { + "core": [ + { + "vuid": "VUID-vkBindBufferMemory-buffer-01029", + "text": " buffer must not already be backed by a memory object" + }, + { + "vuid": "VUID-vkBindBufferMemory-buffer-01030", + "text": " buffer must not have been created with any sparse memory binding flags" + }, + { + "vuid": "VUID-vkBindBufferMemory-memoryOffset-01031", + "text": " memoryOffset must be less than the size of memory" + }, + { + "vuid": "VUID-vkBindBufferMemory-memory-01035", + "text": " memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer" + }, + { + "vuid": "VUID-vkBindBufferMemory-memoryOffset-01036", + "text": " memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer" + }, + { + "vuid": "VUID-vkBindBufferMemory-size-01037", + "text": " The size member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer must be less than or equal to the size of memory minus memoryOffset" + }, + { + "vuid": "VUID-vkBindBufferMemory-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkBindBufferMemory-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkBindBufferMemory-memory-parameter", + "text": " memory must be a valid VkDeviceMemory handle" + }, + { + "vuid": "VUID-vkBindBufferMemory-buffer-parent", + "text": " buffer must have been created, allocated, or retrieved from device" + }, + { + "vuid": "VUID-vkBindBufferMemory-memory-parent", + "text": " memory must have been created, allocated, or retrieved from device" + } + ], + "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + { + "vuid": "VUID-vkBindBufferMemory-buffer-01444", + "text": " If buffer requires a dedicated allocation (as reported by vkGetBufferMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for buffer), memory must have been allocated with VkMemoryDedicatedAllocateInfo::buffer equal to buffer" + }, + { + "vuid": "VUID-vkBindBufferMemory-memory-01508", + "text": " If the VkMemoryAllocateInfo provided when memory was allocated included a VkMemoryDedicatedAllocateInfo structure in its pNext chain, and VkMemoryDedicatedAllocateInfo::buffer was not VK_NULL_HANDLE, then buffer must equal VkMemoryDedicatedAllocateInfo::buffer, and memoryOffset must be zero" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkBindBufferMemory-None-01898", + "text": " If buffer was created with the VK_BUFFER_CREATE_PROTECTED_BIT bit set, the buffer must be bound to a memory object allocated with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT" + }, + { + "vuid": "VUID-vkBindBufferMemory-None-01899", + "text": " If buffer was created with the VK_BUFFER_CREATE_PROTECTED_BIT bit not set, the buffer must not be bound to a memory object allocated with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT" + } + ], + "(VK_NV_dedicated_allocation)": [ + { + "vuid": "VUID-vkBindBufferMemory-buffer-01038", + "text": " If buffer was created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been allocated with VkDedicatedAllocationMemoryAllocateInfoNV::buffer equal to a buffer handle created with identical creation parameters to buffer and memoryOffset must be zero" + } + ], + "(VK_NV_dedicated_allocation)+!(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + { + "vuid": "VUID-vkBindBufferMemory-buffer-01039", + "text": " If buffer was not created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image" + } + ], + "(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-vkBindBufferMemory-memory-02726", + "text": " If the value of VkExportMemoryAllocateInfo::handleTypes used to allocate memory is not 0, it must include at least one of the handles set in VkExternalMemoryBufferCreateInfo::handleTypes when buffer was created" + } + ], + "(VK_VERSION_1_1,VK_KHR_external_memory)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkBindBufferMemory-memory-02727", + "text": " If memory was allocated by a memory import operation, the external handle type of the imported memory must also have been set in VkExternalMemoryBufferCreateInfo::handleTypes when buffer was created" + } + ], + "(VK_VERSION_1_1,VK_KHR_external_memory)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkBindBufferMemory-memory-02985", + "text": " If memory was allocated by a memory import operation, that is not VkImportAndroidHardwareBufferInfoANDROID with a non-NULL buffer value, the external handle type of the imported memory must also have been set in VkExternalMemoryBufferCreateInfo::handleTypes when buffer was created" + }, + { + "vuid": "VUID-vkBindBufferMemory-memory-02986", + "text": " If memory was allocated with the VkImportAndroidHardwareBufferInfoANDROID memory import operation with a non-NULL buffer value, VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID must also have been set in VkExternalMemoryBufferCreateInfo::handleTypes when buffer was created" + } + ], + "(VK_VERSION_1_2,VK_KHR_buffer_device_address)": [ + { + "vuid": "VUID-vkBindBufferMemory-bufferDeviceAddress-03339", + "text": " If the VkPhysicalDeviceBufferDeviceAddressFeatures::bufferDeviceAddress feature is enabled and buffer was created with the VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT bit set, memory must have been allocated with the VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT bit set" + } + ], + "(VK_FUCHSIA_buffer_collection)": [ + { + "vuid": "VUID-vkBindBufferMemory-buffer-06408", + "text": " If buffer was created with VkBufferCollectionBufferCreateInfoFUCHSIA chained to VkBufferCreateInfo::pNext, memory must be allocated with a VkImportMemoryBufferCollectionFUCHSIA chained to VkMemoryAllocateInfo::pNext" + } + ] + }, + "vkBindBufferMemory2": { + "(VK_VERSION_1_1,VK_KHR_bind_memory2)": [ + { + "vuid": "VUID-vkBindBufferMemory2-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkBindBufferMemory2-pBindInfos-parameter", + "text": " pBindInfos must be a valid pointer to an array of bindInfoCount valid VkBindBufferMemoryInfo structures" + }, + { + "vuid": "VUID-vkBindBufferMemory2-bindInfoCount-arraylength", + "text": " bindInfoCount must be greater than 0" + } + ] + }, + "VkBindBufferMemoryInfo": { + "(VK_VERSION_1_1,VK_KHR_bind_memory2)": [ + { + "vuid": "VUID-VkBindBufferMemoryInfo-buffer-01029", + "text": " buffer must not already be backed by a memory object" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-buffer-01030", + "text": " buffer must not have been created with any sparse memory binding flags" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-memoryOffset-01031", + "text": " memoryOffset must be less than the size of memory" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-memory-01035", + "text": " memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-memoryOffset-01036", + "text": " memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-size-01037", + "text": " The size member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer must be less than or equal to the size of memory minus memoryOffset" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkBindBufferMemoryDeviceGroupInfo" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-memory-parameter", + "text": " memory must be a valid VkDeviceMemory handle" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-commonparent", + "text": " Both of buffer, and memory must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + { + "vuid": "VUID-VkBindBufferMemoryInfo-buffer-01444", + "text": " If buffer requires a dedicated allocation (as reported by vkGetBufferMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for buffer), memory must have been allocated with VkMemoryDedicatedAllocateInfo::buffer equal to buffer" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-memory-01508", + "text": " If the VkMemoryAllocateInfo provided when memory was allocated included a VkMemoryDedicatedAllocateInfo structure in its pNext chain, and VkMemoryDedicatedAllocateInfo::buffer was not VK_NULL_HANDLE, then buffer must equal VkMemoryDedicatedAllocateInfo::buffer, and memoryOffset must be zero" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkBindBufferMemoryInfo-None-01898", + "text": " If buffer was created with the VK_BUFFER_CREATE_PROTECTED_BIT bit set, the buffer must be bound to a memory object allocated with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-None-01899", + "text": " If buffer was created with the VK_BUFFER_CREATE_PROTECTED_BIT bit not set, the buffer must not be bound to a memory object allocated with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)": [ + { + "vuid": "VUID-VkBindBufferMemoryInfo-buffer-01038", + "text": " If buffer was created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been allocated with VkDedicatedAllocationMemoryAllocateInfoNV::buffer equal to a buffer handle created with identical creation parameters to buffer and memoryOffset must be zero" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)+!(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + { + "vuid": "VUID-VkBindBufferMemoryInfo-buffer-01039", + "text": " If buffer was not created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkBindBufferMemoryInfo-memory-02726", + "text": " If the value of VkExportMemoryAllocateInfo::handleTypes used to allocate memory is not 0, it must include at least one of the handles set in VkExternalMemoryBufferCreateInfo::handleTypes when buffer was created" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_external_memory)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkBindBufferMemoryInfo-memory-02727", + "text": " If memory was allocated by a memory import operation, the external handle type of the imported memory must also have been set in VkExternalMemoryBufferCreateInfo::handleTypes when buffer was created" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_external_memory)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkBindBufferMemoryInfo-memory-02985", + "text": " If memory was allocated by a memory import operation, that is not VkImportAndroidHardwareBufferInfoANDROID with a non-NULL buffer value, the external handle type of the imported memory must also have been set in VkExternalMemoryBufferCreateInfo::handleTypes when buffer was created" + }, + { + "vuid": "VUID-VkBindBufferMemoryInfo-memory-02986", + "text": " If memory was allocated with the VkImportAndroidHardwareBufferInfoANDROID memory import operation with a non-NULL buffer value, VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID must also have been set in VkExternalMemoryBufferCreateInfo::handleTypes when buffer was created" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_2,VK_KHR_buffer_device_address)": [ + { + "vuid": "VUID-VkBindBufferMemoryInfo-bufferDeviceAddress-03339", + "text": " If the VkPhysicalDeviceBufferDeviceAddressFeatures::bufferDeviceAddress feature is enabled and buffer was created with the VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT bit set, memory must have been allocated with the VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT bit set" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_FUCHSIA_buffer_collection)": [ + { + "vuid": "VUID-VkBindBufferMemoryInfo-buffer-06408", + "text": " If buffer was created with VkBufferCollectionBufferCreateInfoFUCHSIA chained to VkBufferCreateInfo::pNext, memory must be allocated with a VkImportMemoryBufferCollectionFUCHSIA chained to VkMemoryAllocateInfo::pNext" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkBindBufferMemoryInfo-pNext-01605", + "text": " If the pNext chain includes a VkBindBufferMemoryDeviceGroupInfo structure, all instances of memory specified by VkBindBufferMemoryDeviceGroupInfo::pDeviceIndices must have been allocated" + } + ] + }, + "VkBindBufferMemoryDeviceGroupInfo": { + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkBindBufferMemoryDeviceGroupInfo-deviceIndexCount-01606", + "text": " deviceIndexCount must either be zero or equal to the number of physical devices in the logical device" + }, + { + "vuid": "VUID-VkBindBufferMemoryDeviceGroupInfo-pDeviceIndices-01607", + "text": " All elements of pDeviceIndices must be valid device indices" + }, + { + "vuid": "VUID-VkBindBufferMemoryDeviceGroupInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO" + }, + { + "vuid": "VUID-VkBindBufferMemoryDeviceGroupInfo-pDeviceIndices-parameter", + "text": " If deviceIndexCount is not 0, pDeviceIndices must be a valid pointer to an array of deviceIndexCount uint32_t values" + } + ] + }, + "vkBindImageMemory": { + "core": [ + { + "vuid": "VUID-vkBindImageMemory-image-01044", + "text": " image must not already be backed by a memory object" + }, + { + "vuid": "VUID-vkBindImageMemory-image-01045", + "text": " image must not have been created with any sparse memory binding flags" + }, + { + "vuid": "VUID-vkBindImageMemory-memoryOffset-01046", + "text": " memoryOffset must be less than the size of memory" + }, + { + "vuid": "VUID-vkBindImageMemory-memory-01047", + "text": " memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image" + }, + { + "vuid": "VUID-vkBindImageMemory-memoryOffset-01048", + "text": " memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image" + }, + { + "vuid": "VUID-vkBindImageMemory-size-01049", + "text": " The difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with the same image" + }, + { + "vuid": "VUID-vkBindImageMemory-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkBindImageMemory-image-parameter", + "text": " image must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkBindImageMemory-memory-parameter", + "text": " memory must be a valid VkDeviceMemory handle" + }, + { + "vuid": "VUID-vkBindImageMemory-image-parent", + "text": " image must have been created, allocated, or retrieved from device" + }, + { + "vuid": "VUID-vkBindImageMemory-memory-parent", + "text": " memory must have been created, allocated, or retrieved from device" + } + ], + "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + { + "vuid": "VUID-vkBindImageMemory-image-01445", + "text": " If image requires a dedicated allocation (as reported by vkGetImageMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for image), memory must have been created with VkMemoryDedicatedAllocateInfo::image equal to image" + } + ], + "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+!(VK_NV_dedicated_allocation_image_aliasing)": [ + { + "vuid": "VUID-vkBindImageMemory-memory-01509", + "text": " If the VkMemoryAllocateInfo provided when memory was allocated included a VkMemoryDedicatedAllocateInfo structure in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then image must equal VkMemoryDedicatedAllocateInfo::image and memoryOffset must be zero" + } + ], + "(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_NV_dedicated_allocation_image_aliasing)": [ + { + "vuid": "VUID-vkBindImageMemory-memory-02628", + "text": " If the dedicated allocation image aliasing feature is not enabled, and the VkMemoryAllocateInfo provided when memory was allocated included a VkMemoryDedicatedAllocateInfo structure in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then image must equal VkMemoryDedicatedAllocateInfo::image and memoryOffset must be zero" + }, + { + "vuid": "VUID-vkBindImageMemory-memory-02629", + "text": " If the dedicated allocation image aliasing feature is enabled, and the VkMemoryAllocateInfo provided when memory was allocated included a VkMemoryDedicatedAllocateInfo structure in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then memoryOffset must be zero, and image must be either equal to VkMemoryDedicatedAllocateInfo::image or an image that was created using the same parameters in VkImageCreateInfo, with the exception that extent and arrayLayers may differ subject to the following restrictions: every dimension in the extent parameter of the image being bound must be equal to or smaller than the original image for which the allocation was created; and the arrayLayers parameter of the image being bound must be equal to or smaller than the original image for which the allocation was created" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkBindImageMemory-None-01901", + "text": " If image was created with the VK_IMAGE_CREATE_PROTECTED_BIT bit set, the image must be bound to a memory object allocated with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT" + }, + { + "vuid": "VUID-vkBindImageMemory-None-01902", + "text": " If image was created with the VK_IMAGE_CREATE_PROTECTED_BIT bit not set, the image must not be bound to a memory object created with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT" + } + ], + "(VK_NV_dedicated_allocation)": [ + { + "vuid": "VUID-vkBindImageMemory-image-01050", + "text": " If image was created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::image equal to an image handle created with identical creation parameters to image and memoryOffset must be zero" + } + ], + "(VK_NV_dedicated_allocation)+!(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + { + "vuid": "VUID-vkBindImageMemory-image-01051", + "text": " If image was not created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image" + } + ], + "(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-vkBindImageMemory-memory-02728", + "text": " If the value of VkExportMemoryAllocateInfo::handleTypes used to allocate memory is not 0, it must include at least one of the handles set in VkExternalMemoryImageCreateInfo::handleTypes when image was created" + } + ], + "(VK_VERSION_1_1,VK_KHR_external_memory)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkBindImageMemory-memory-02729", + "text": " If memory was created by a memory import operation, the external handle type of the imported memory must also have been set in VkExternalMemoryImageCreateInfo::handleTypes when image was created" + } + ], + "(VK_VERSION_1_1,VK_KHR_external_memory)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkBindImageMemory-memory-02989", + "text": " If memory was created by a memory import operation, that is not VkImportAndroidHardwareBufferInfoANDROID with a non-NULL buffer value, the external handle type of the imported memory must also have been set in VkExternalMemoryImageCreateInfo::handleTypes when image was created" + }, + { + "vuid": "VUID-vkBindImageMemory-memory-02990", + "text": " If memory was created with the VkImportAndroidHardwareBufferInfoANDROID memory import operation with a non-NULL buffer value, VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID must also have been set in VkExternalMemoryImageCreateInfo::handleTypes when image was created" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkBindImageMemory-image-01608", + "text": " image must not have been created with the VK_IMAGE_CREATE_DISJOINT_BIT set" + } + ], + "(VK_FUCHSIA_buffer_collection)": [ + { + "vuid": "VUID-vkBindImageMemory-image-06392", + "text": " If image was created with VkBufferCollectionImageCreateInfoFUCHSIA chained to VkImageCreateInfo::pNext, memory must be allocated with a VkImportMemoryBufferCollectionFUCHSIA chained to VkMemoryAllocateInfo::pNext" + } + ] + }, + "vkBindImageMemory2": { + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkBindImageMemory2-pBindInfos-02858", + "text": " If any VkBindImageMemoryInfo::image was created with VK_IMAGE_CREATE_DISJOINT_BIT then all planes of VkBindImageMemoryInfo::image must be bound individually in separate pBindInfos" + }, + { + "vuid": "VUID-vkBindImageMemory2-pBindInfos-04006", + "text": " pBindInfos must not refer to the same image subresource more than once" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)": [ + { + "vuid": "VUID-vkBindImageMemory2-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkBindImageMemory2-pBindInfos-parameter", + "text": " pBindInfos must be a valid pointer to an array of bindInfoCount valid VkBindImageMemoryInfo structures" + }, + { + "vuid": "VUID-vkBindImageMemory2-bindInfoCount-arraylength", + "text": " bindInfoCount must be greater than 0" + } + ] + }, + "VkBindImageMemoryInfo": { + "(VK_VERSION_1_1,VK_KHR_bind_memory2)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-image-01044", + "text": " image must not already be backed by a memory object" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-image-01045", + "text": " image must not have been created with any sparse memory binding flags" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-memoryOffset-01046", + "text": " memoryOffset must be less than the size of memory" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkBindImageMemoryDeviceGroupInfo, VkBindImageMemorySwapchainInfoKHR, or VkBindImagePlaneMemoryInfo" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-image-parameter", + "text": " image must be a valid VkImage handle" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-commonparent", + "text": " Both of image, and memory that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-image-01445", + "text": " If image requires a dedicated allocation (as reported by vkGetImageMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for image), memory must have been created with VkMemoryDedicatedAllocateInfo::image equal to image" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+!(VK_NV_dedicated_allocation_image_aliasing)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-memory-01509", + "text": " If the VkMemoryAllocateInfo provided when memory was allocated included a VkMemoryDedicatedAllocateInfo structure in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then image must equal VkMemoryDedicatedAllocateInfo::image and memoryOffset must be zero" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_dedicated_allocation)+(VK_NV_dedicated_allocation_image_aliasing)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-memory-02628", + "text": " If the dedicated allocation image aliasing feature is not enabled, and the VkMemoryAllocateInfo provided when memory was allocated included a VkMemoryDedicatedAllocateInfo structure in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then image must equal VkMemoryDedicatedAllocateInfo::image and memoryOffset must be zero" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-memory-02629", + "text": " If the dedicated allocation image aliasing feature is enabled, and the VkMemoryAllocateInfo provided when memory was allocated included a VkMemoryDedicatedAllocateInfo structure in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then memoryOffset must be zero, and image must be either equal to VkMemoryDedicatedAllocateInfo::image or an image that was created using the same parameters in VkImageCreateInfo, with the exception that extent and arrayLayers may differ subject to the following restrictions: every dimension in the extent parameter of the image being bound must be equal to or smaller than the original image for which the allocation was created; and the arrayLayers parameter of the image being bound must be equal to or smaller than the original image for which the allocation was created" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-None-01901", + "text": " If image was created with the VK_IMAGE_CREATE_PROTECTED_BIT bit set, the image must be bound to a memory object allocated with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-None-01902", + "text": " If image was created with the VK_IMAGE_CREATE_PROTECTED_BIT bit not set, the image must not be bound to a memory object created with a memory type that reports VK_MEMORY_PROPERTY_PROTECTED_BIT" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-image-01050", + "text": " If image was created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::image equal to an image handle created with identical creation parameters to image and memoryOffset must be zero" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_NV_dedicated_allocation)+!(VK_VERSION_1_1,VK_KHR_dedicated_allocation)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-image-01051", + "text": " If image was not created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-memory-02728", + "text": " If the value of VkExportMemoryAllocateInfo::handleTypes used to allocate memory is not 0, it must include at least one of the handles set in VkExternalMemoryImageCreateInfo::handleTypes when image was created" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_external_memory)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-memory-02729", + "text": " If memory was created by a memory import operation, the external handle type of the imported memory must also have been set in VkExternalMemoryImageCreateInfo::handleTypes when image was created" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_external_memory)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-memory-02989", + "text": " If memory was created by a memory import operation, that is not VkImportAndroidHardwareBufferInfoANDROID with a non-NULL buffer value, the external handle type of the imported memory must also have been set in VkExternalMemoryImageCreateInfo::handleTypes when image was created" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-memory-02990", + "text": " If memory was created with the VkImportAndroidHardwareBufferInfoANDROID memory import operation with a non-NULL buffer value, VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID must also have been set in VkExternalMemoryImageCreateInfo::handleTypes when image was created" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-memory-01612", + "text": " memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-memoryOffset-01613", + "text": " memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-memory-01614", + "text": " The difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with the same image" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01615", + "text": " If the pNext chain does not include a VkBindImagePlaneMemoryInfo structure, memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01616", + "text": " If the pNext chain does not include a VkBindImagePlaneMemoryInfo structure, memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01617", + "text": " If the pNext chain does not include a VkBindImagePlaneMemoryInfo structure, the difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with the same image" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01618", + "text": " If the pNext chain includes a VkBindImagePlaneMemoryInfo structure, image must have been created with the VK_IMAGE_CREATE_DISJOINT_BIT bit set" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01619", + "text": " If the pNext chain includes a VkBindImagePlaneMemoryInfo structure, memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image and where VkBindImagePlaneMemoryInfo::planeAspect corresponds to the VkImagePlaneMemoryRequirementsInfo::planeAspect in the VkImageMemoryRequirementsInfo2 structure’s pNext chain" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01620", + "text": " If the pNext chain includes a VkBindImagePlaneMemoryInfo structure, memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image and where VkBindImagePlaneMemoryInfo::planeAspect corresponds to the VkImagePlaneMemoryRequirementsInfo::planeAspect in the VkImageMemoryRequirementsInfo2 structure’s pNext chain" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01621", + "text": " If the pNext chain includes a VkBindImagePlaneMemoryInfo structure, the difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with the same image and where VkBindImagePlaneMemoryInfo::planeAspect corresponds to the VkImagePlaneMemoryRequirementsInfo::planeAspect in the VkImageMemoryRequirementsInfo2 structure’s pNext chain" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+!(VK_VERSION_1_1+VK_KHR_swapchain)+!(VK_KHR_device_group+VK_KHR_swapchain)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-memory-01625", + "text": " memory must be a valid VkDeviceMemory handle" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01626", + "text": " If the pNext chain includes a VkBindImageMemoryDeviceGroupInfo structure, all instances of memory specified by VkBindImageMemoryDeviceGroupInfo::pDeviceIndices must have been allocated" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01627", + "text": " If the pNext chain includes a VkBindImageMemoryDeviceGroupInfo structure, and VkBindImageMemoryDeviceGroupInfo::splitInstanceBindRegionCount is not zero, then image must have been created with the VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT bit set" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01628", + "text": " If the pNext chain includes a VkBindImageMemoryDeviceGroupInfo structure, all elements of VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions must be valid rectangles contained within the dimensions of image" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01629", + "text": " If the pNext chain includes a VkBindImageMemoryDeviceGroupInfo structure, the union of the areas of all elements of VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions that correspond to the same instance of image must cover the entire image" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)": [ + { + "vuid": "VUID-VkBindImageMemoryInfo-image-01630", + "text": " If image was created with a valid swapchain handle in VkImageSwapchainCreateInfoKHR::swapchain, then the pNext chain must include a VkBindImageMemorySwapchainInfoKHR structure containing the same swapchain handle" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01631", + "text": " If the pNext chain includes a VkBindImageMemorySwapchainInfoKHR structure, memory must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkBindImageMemoryInfo-pNext-01632", + "text": " If the pNext chain does not include a VkBindImageMemorySwapchainInfoKHR structure, memory must be a valid VkDeviceMemory handle" + } + ] + }, + "VkBindImageMemoryDeviceGroupInfo": { + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01633", + "text": " At least one of deviceIndexCount and splitInstanceBindRegionCount must be zero" + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-splitInstanceBindRegionCount-01636", + "text": " splitInstanceBindRegionCount must either be zero or equal to the number of physical devices in the logical device squared" + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-pSplitInstanceBindRegions-01637", + "text": " Elements of pSplitInstanceBindRegions that correspond to the same instance of an image must not overlap" + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-offset-01638", + "text": " The offset.x member of any element of pSplitInstanceBindRegions must be a multiple of the sparse image block width (VkSparseImageFormatProperties::imageGranularity.width) of all non-metadata aspects of the image" + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-offset-01639", + "text": " The offset.y member of any element of pSplitInstanceBindRegions must be a multiple of the sparse image block height (VkSparseImageFormatProperties::imageGranularity.height) of all non-metadata aspects of the image" + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-extent-01640", + "text": " The extent.width member of any element of pSplitInstanceBindRegions must either be a multiple of the sparse image block width of all non-metadata aspects of the image, or else extent.width + offset.x must equal the width of the image subresource" + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-extent-01641", + "text": " The extent.height member of any element of pSplitInstanceBindRegions must either be a multiple of the sparse image block height of all non-metadata aspects of the image, or else extent.height + offset.y must equal the height of the image subresource" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-deviceIndexCount-01634", + "text": " deviceIndexCount must either be zero or equal to the number of physical devices in the logical device" + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-pDeviceIndices-01635", + "text": " All elements of pDeviceIndices must be valid device indices" + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO" + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-pDeviceIndices-parameter", + "text": " If deviceIndexCount is not 0, pDeviceIndices must be a valid pointer to an array of deviceIndexCount uint32_t values" + }, + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-pSplitInstanceBindRegions-parameter", + "text": " If splitInstanceBindRegionCount is not 0, pSplitInstanceBindRegions must be a valid pointer to an array of splitInstanceBindRegionCount VkRect2D structures" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkBindImageMemoryDeviceGroupInfo-splitInstanceBindRegionCount-05067", + "text": " splitInstanceBindRegionCount must be zero" + } + ] + }, + "VkBindImageMemorySwapchainInfoKHR": { + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_swapchain)": [ + { + "vuid": "VUID-VkBindImageMemorySwapchainInfoKHR-imageIndex-01644", + "text": " imageIndex must be less than the number of images in swapchain" + }, + { + "vuid": "VUID-VkBindImageMemorySwapchainInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR" + }, + { + "vuid": "VUID-VkBindImageMemorySwapchainInfoKHR-swapchain-parameter", + "text": " swapchain must be a valid VkSwapchainKHR handle" + } + ] + }, + "VkBindImagePlaneMemoryInfo": { + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkBindImagePlaneMemoryInfo-planeAspect-02283", + "text": " If the image’s tiling is VK_IMAGE_TILING_LINEAR or VK_IMAGE_TILING_OPTIMAL, then planeAspect must be a single valid format plane for the image (that is, for a two-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT, and for a three-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT)" + }, + { + "vuid": "VUID-VkBindImagePlaneMemoryInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO" + }, + { + "vuid": "VUID-VkBindImagePlaneMemoryInfo-planeAspect-parameter", + "text": " planeAspect must be a valid VkImageAspectFlagBits value" + } + ], + "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_image_drm_format_modifier)": [ + { + "vuid": "VUID-VkBindImagePlaneMemoryInfo-planeAspect-02284", + "text": " If the image’s tiling is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, then planeAspect must be a single valid memory plane for the image (that is, aspectMask must specify a plane index that is less than the VkDrmFormatModifierPropertiesEXT::drmFormatModifierPlaneCount associated with the image’s format and VkImageDrmFormatModifierPropertiesEXT::drmFormatModifier)" + } + ] + }, + "VkBufferCollectionCreateInfoFUCHSIA": { + "(VK_FUCHSIA_buffer_collection)": [ + { + "vuid": "VUID-VkBufferCollectionCreateInfoFUCHSIA-collectionToken-06393", + "text": " collectionToken must be a valid zx_handle_t to a Zircon channel allocated from Sysmem (fuchsia.sysmem.Allocator/AllocateSharedCollection) with ZX_DEFAULT_CHANNEL_RIGHTS rights" + } + ] + }, + "vkSetBufferCollectionImageConstraintsFUCHSIA": { + "(VK_FUCHSIA_buffer_collection)": [ + { + "vuid": "VUID-vkSetBufferCollectionImageConstraintsFUCHSIA-collection-06394", + "text": " vkSetBufferCollectionImageConstraintsFUCHSIA or vkSetBufferCollectionBufferConstraintsFUCHSIA must not have already been called on collection" + } + ] + }, + "VkImageConstraintsInfoFUCHSIA": { + "(VK_FUCHSIA_buffer_collection)": [ + { + "vuid": "VUID-VkImageConstraintsInfoFUCHSIA-pFormatConstraints-06395", + "text": " All elements of pFormatConstraints must have at least one bit set in its VkImageFormatConstraintsInfoFUCHSIA::requiredFormatFeatures" + }, + { + "vuid": "VUID-VkImageConstraintsInfoFUCHSIA-pFormatConstraints-06396", + "text": " If pFormatConstraints::imageCreateInfo::usage contains VK_IMAGE_USAGE_SAMPLED_BIT, then pFormatConstraints::requiredFormatFeatures must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT" + }, + { + "vuid": "VUID-VkImageConstraintsInfoFUCHSIA-pFormatConstraints-06397", + "text": " If pFormatConstraints::imageCreateInfo::usage contains VK_IMAGE_USAGE_STORAGE_BIT, then pFormatConstraints::requiredFormatFeatures must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT" + }, + { + "vuid": "VUID-VkImageConstraintsInfoFUCHSIA-pFormatConstraints-06398", + "text": " If pFormatConstraints::imageCreateInfo::usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, then pFormatConstraints::requiredFormatFeatures must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageConstraintsInfoFUCHSIA-pFormatConstraints-06399", + "text": " If pFormatConstraints::imageCreateInfo::usage contains VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, then pFormatConstraints::requiredFormatFeatures must contain VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkImageConstraintsInfoFUCHSIA-pFormatConstraints-06400", + "text": " If pFormatConstraints::imageCreateInfo::usage contains VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, then pFormatConstraints::requiredFormatFeatures must contain at least one of VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT or VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT" + } + ], + "(VK_FUCHSIA_buffer_collection)+(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-VkImageConstraintsInfoFUCHSIA-attachmentFragmentShadingRate-06401", + "text": " If the attachmentFragmentShadingRate feature is enabled, and pFormatConstraints::imageCreateInfo::usage contains VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, then pFormatConstraints::requiredFormatFeatures must contain VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" + } + ] + }, + "VkSysmemColorSpaceFUCHSIA": { + "(VK_FUCHSIA_buffer_collection)": [ + { + "vuid": "VUID-VkSysmemColorSpaceFUCHSIA-colorSpace-06402", + "text": " colorSpace must be a ColorSpaceType as defined in fuchsia.sysmem/image_formats.fidl" + } + ] + }, + "vkSetBufferCollectionBufferConstraintsFUCHSIA": { + "(VK_FUCHSIA_buffer_collection)": [ + { + "vuid": "VUID-vkSetBufferCollectionBufferConstraintsFUCHSIA-collection-06403", + "text": " vkSetBufferCollectionImageConstraintsFUCHSIA or vkSetBufferCollectionBufferConstraintsFUCHSIA must not have already been called on collection" + } + ] + }, + "VkBufferConstraintsInfoFUCHSIA": { + "(VK_FUCHSIA_buffer_collection)": [ + { + "vuid": "VUID-VkBufferConstraintsInfoFUCHSIA-requiredFormatFeatures-06404", + "text": " The requiredFormatFeatures bitmask of VkFormatFeatureFlagBits must be chosen from among the buffer compatible format features listed in buffer compatible format features" + } + ] + }, + "vkGetBufferCollectionPropertiesFUCHSIA": { + "(VK_FUCHSIA_buffer_collection)": [ + { + "vuid": "VUID-vkGetBufferCollectionPropertiesFUCHSIA-None-06405", + "text": " Prior to calling vkGetBufferCollectionPropertiesFUCHSIA, the constraints on the buffer collection must have been set by either vkSetBufferCollectionImageConstraintsFUCHSIA or vkSetBufferCollectionBufferConstraintsFUCHSIA." + } + ] + }, + "VkImportMemoryBufferCollectionFUCHSIA": { + "(VK_FUCHSIA_buffer_collection)": [ + { + "vuid": "VUID-VkImportMemoryBufferCollectionFUCHSIA-index-06406", + "text": " index must be less than the value retrieved as VkBufferCollectionPropertiesFUCHSIA:bufferCount" + } + ] + }, + "vkDestroyBufferCollectionFUCHSIA": { + "(VK_FUCHSIA_buffer_collection)": [ + { + "vuid": "VUID-vkDestroyBufferCollectionFUCHSIA-collection-06407", + "text": " VkImage and VkBuffer objects that referenced collection upon creation by inclusion of a VkBufferCollectionImageCreateInfoFUCHSIA or VkBufferCollectionBufferCreateInfoFUCHSIA chained to their VkImageCreateInfo or VkBufferCreateInfo structures respectively, may outlive collection." + } + ] + }, + "vkCreateSampler": { + "core": [ + { + "vuid": "VUID-vkCreateSampler-maxSamplerAllocationCount-04110", + "text": " There must be less than VkPhysicalDeviceLimits::maxSamplerAllocationCount VkSampler objects currently created on the device" + }, + { + "vuid": "VUID-vkCreateSampler-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateSampler-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkSamplerCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateSampler-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateSampler-pSampler-parameter", + "text": " pSampler must be a valid pointer to a VkSampler handle" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateSampler-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ] + }, + "VkSamplerCreateInfo": { + "core": [ + { + "vuid": "VUID-VkSamplerCreateInfo-mipLodBias-01069", + "text": " The absolute value of mipLodBias must be less than or equal to VkPhysicalDeviceLimits::maxSamplerLodBias" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-maxLod-01973", + "text": " maxLod must be greater than or equal to minLod" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-anisotropyEnable-01070", + "text": " If the anisotropic sampling feature is not enabled, anisotropyEnable must be VK_FALSE" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-anisotropyEnable-01071", + "text": " If anisotropyEnable is VK_TRUE, maxAnisotropy must be between 1.0 and VkPhysicalDeviceLimits::maxSamplerAnisotropy, inclusive" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01072", + "text": " If unnormalizedCoordinates is VK_TRUE, minFilter and magFilter must be equal" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01073", + "text": " If unnormalizedCoordinates is VK_TRUE, mipmapMode must be VK_SAMPLER_MIPMAP_MODE_NEAREST" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01074", + "text": " If unnormalizedCoordinates is VK_TRUE, minLod and maxLod must be zero" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01075", + "text": " If unnormalizedCoordinates is VK_TRUE, addressModeU and addressModeV must each be either VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE or VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01076", + "text": " If unnormalizedCoordinates is VK_TRUE, anisotropyEnable must be VK_FALSE" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01077", + "text": " If unnormalizedCoordinates is VK_TRUE, compareEnable must be VK_FALSE" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-addressModeU-01078", + "text": " If any of addressModeU, addressModeV or addressModeW are VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, borderColor must be a valid VkBorderColor value" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-addressModeU-01079", + "text": " If samplerMirrorClampToEdge is not enabled, and if the VK_KHR_sampler_mirror_clamp_to_edge extension is not enabled, addressModeU, addressModeV and addressModeW must not be VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-compareEnable-01080", + "text": " If compareEnable is VK_TRUE, compareOp must be a valid VkCompareOp value" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkSamplerCustomBorderColorCreateInfoEXT, VkSamplerReductionModeCreateInfo, or VkSamplerYcbcrConversionInfo" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-magFilter-parameter", + "text": " magFilter must be a valid VkFilter value" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-minFilter-parameter", + "text": " minFilter must be a valid VkFilter value" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-mipmapMode-parameter", + "text": " mipmapMode must be a valid VkSamplerMipmapMode value" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-addressModeU-parameter", + "text": " addressModeU must be a valid VkSamplerAddressMode value" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-addressModeV-parameter", + "text": " addressModeV must be a valid VkSamplerAddressMode value" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-addressModeW-parameter", + "text": " addressModeW must be a valid VkSamplerAddressMode value" + } + ], + "(VK_KHR_portability_subset)": [ + { + "vuid": "VUID-VkSamplerCreateInfo-samplerMipLodBias-04467", + "text": " If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::samplerMipLodBias is VK_FALSE, mipLodBias must be zero" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkSamplerCreateInfo-minFilter-01645", + "text": " If sampler {YCbCr} conversion is enabled and the potential format features of the sampler {YCbCr} conversion do not support VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, minFilter and magFilter must be equal to the sampler {YCbCr} conversion’s chromaFilter" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-addressModeU-01646", + "text": " If sampler {YCbCr} conversion is enabled, addressModeU, addressModeV, and addressModeW must be VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, anisotropyEnable must be VK_FALSE, and unnormalizedCoordinates must be VK_FALSE" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_VERSION_1_2,VK_EXT_sampler_filter_minmax)": [ + { + "vuid": "VUID-VkSamplerCreateInfo-None-01647", + "text": " The sampler reduction mode must be set to VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE if sampler {YCbCr} conversion is enabled" + } + ], + "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-VkSamplerCreateInfo-magFilter-01081", + "text": " If either magFilter or minFilter is VK_FILTER_CUBIC_EXT, anisotropyEnable must be VK_FALSE" + } + ], + "(VK_IMG_filter_cubic+VK_EXT_sampler_filter_minmax)+!(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-VkSamplerCreateInfo-magFilter-01422", + "text": " If either magFilter or minFilter is VK_FILTER_CUBIC_EXT, the reductionMode member of VkSamplerReductionModeCreateInfo must be VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE" + } + ], + "(VK_VERSION_1_2,VK_EXT_sampler_filter_minmax)": [ + { + "vuid": "VUID-VkSamplerCreateInfo-compareEnable-01423", + "text": " If compareEnable is VK_TRUE, the reductionMode member of VkSamplerReductionModeCreateInfo must be VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE" + } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkSamplerCreateInfo-flags-02574", + "text": " If flags includes VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, then minFilter and magFilter must be equal" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-flags-02575", + "text": " If flags includes VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, then mipmapMode must be VK_SAMPLER_MIPMAP_MODE_NEAREST" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-flags-02576", + "text": " If flags includes VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, then minLod and maxLod must be zero" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-flags-02577", + "text": " If flags includes VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, then addressModeU and addressModeV must each be either VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE or VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-flags-02578", + "text": " If flags includes VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, then anisotropyEnable must be VK_FALSE" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-flags-02579", + "text": " If flags includes VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, then compareEnable must be VK_FALSE" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-flags-02580", + "text": " If flags includes VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, then unnormalizedCoordinates must be VK_FALSE" + } + ], + "(VK_EXT_custom_border_color)": [ + { + "vuid": "VUID-VkSamplerCreateInfo-borderColor-04011", + "text": " If borderColor is one of VK_BORDER_COLOR_FLOAT_CUSTOM_EXT or VK_BORDER_COLOR_INT_CUSTOM_EXT, then a VkSamplerCustomBorderColorCreateInfoEXT must be included in the pNext chain" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-customBorderColors-04085", + "text": " If the customBorderColors feature is not enabled, borderColor must not be VK_BORDER_COLOR_FLOAT_CUSTOM_EXT or VK_BORDER_COLOR_INT_CUSTOM_EXT" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-borderColor-04442", + "text": " If borderColor is one of VK_BORDER_COLOR_FLOAT_CUSTOM_EXT or VK_BORDER_COLOR_INT_CUSTOM_EXT, and VkSamplerCustomBorderColorCreateInfoEXT::format is not VK_FORMAT_UNDEFINED, VkSamplerCustomBorderColorCreateInfoEXT::customBorderColor must be within the range of values representable in format" + }, + { + "vuid": "VUID-VkSamplerCreateInfo-None-04012", + "text": " The maximum number of samplers with custom border colors which can be simultaneously created on a device is implementation-dependent and specified by the maxCustomBorderColorSamplers member of the VkPhysicalDeviceCustomBorderColorPropertiesEXT structure" + } + ] + }, + "VkSamplerReductionModeCreateInfo": { + "(VK_VERSION_1_2,VK_EXT_sampler_filter_minmax)": [ + { + "vuid": "VUID-VkSamplerReductionModeCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO" + }, + { + "vuid": "VUID-VkSamplerReductionModeCreateInfo-reductionMode-parameter", + "text": " reductionMode must be a valid VkSamplerReductionMode value" + } + ] + }, + "vkDestroySampler": { + "core": [ + { + "vuid": "VUID-vkDestroySampler-sampler-01082", + "text": " All submitted commands that refer to sampler must have completed execution" + }, + { + "vuid": "VUID-vkDestroySampler-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroySampler-sampler-parameter", + "text": " If sampler is not VK_NULL_HANDLE, sampler must be a valid VkSampler handle" + }, + { + "vuid": "VUID-vkDestroySampler-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroySampler-sampler-parent", + "text": " If sampler is a valid handle, it must have been created, allocated, or retrieved from device" + } + ], + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroySampler-sampler-01083", + "text": " If VkAllocationCallbacks were provided when sampler was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroySampler-sampler-01084", + "text": " If no VkAllocationCallbacks were provided when sampler was created, pAllocator must be NULL" + } + ] + }, + "VkSamplerYcbcrConversionInfo": { + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkSamplerYcbcrConversionInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionInfo-conversion-parameter", + "text": " conversion must be a valid VkSamplerYcbcrConversion handle" + } + ] + }, + "vkCreateSamplerYcbcrConversion": { + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkCreateSamplerYcbcrConversion-None-01648", + "text": " The sampler {YCbCr} conversion feature must be enabled" + }, + { + "vuid": "VUID-vkCreateSamplerYcbcrConversion-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateSamplerYcbcrConversion-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkSamplerYcbcrConversionCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateSamplerYcbcrConversion-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateSamplerYcbcrConversion-pYcbcrConversion-parameter", + "text": " pYcbcrConversion must be a valid pointer to a VkSamplerYcbcrConversion handle" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateSamplerYcbcrConversion-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ] + }, + "VkSamplerYcbcrConversionCreateInfo": { + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-format-04060", + "text": " format must represent unsigned normalized values (i.e. the format must be a UNORM format)" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-format-01904", + "text": " If an external format conversion is being created, format must be VK_FORMAT_UNDEFINED" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-format-04061", + "text": " If an external format conversion is not being created, format must represent unsigned normalized values (i.e. the format must be a UNORM format)" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-format-01650", + "text": " The potential format features of the sampler {YCbCr} conversion must support VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT or VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-01651", + "text": " If the potential format features of the sampler {YCbCr} conversion do not support VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, xChromaOffset and yChromaOffset must not be VK_CHROMA_LOCATION_COSITED_EVEN if the corresponding components are downsampled" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-01652", + "text": " If the potential format features of the sampler {YCbCr} conversion do not support VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, xChromaOffset and yChromaOffset must not be VK_CHROMA_LOCATION_MIDPOINT if the corresponding components are downsampled" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-components-02581", + "text": " If the format has a _422 or _420 suffix, then components.g must be the identity swizzle" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-components-02582", + "text": " If the format has a _422 or _420 suffix, then components.a must be the identity swizzle, VK_COMPONENT_SWIZZLE_ONE, or VK_COMPONENT_SWIZZLE_ZERO" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-components-02583", + "text": " If the format has a _422 or _420 suffix, then components.r must be the identity swizzle or VK_COMPONENT_SWIZZLE_B" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-components-02584", + "text": " If the format has a _422 or _420 suffix, then components.b must be the identity swizzle or VK_COMPONENT_SWIZZLE_R" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-components-02585", + "text": " If the format has a _422 or _420 suffix, and if either components.r or components.b is the identity swizzle, both values must be the identity swizzle" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-01655", + "text": " If ycbcrModel is not VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, then components.r, components.g, and components.b must correspond to components of the format; that is, components.r, components.g, and components.b must not be VK_COMPONENT_SWIZZLE_ZERO or VK_COMPONENT_SWIZZLE_ONE, and must not correspond to a component containing zero or one as a consequence of conversion to RGBA" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrRange-02748", + "text": " If ycbcrRange is VK_SAMPLER_YCBCR_RANGE_ITU_NARROW then the R, G and B components obtained by applying the component swizzle to format must each have a bit-depth greater than or equal to 8" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-forceExplicitReconstruction-01656", + "text": " If the potential format features of the sampler {YCbCr} conversion do not support VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT forceExplicitReconstruction must be VK_FALSE" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-chromaFilter-01657", + "text": " If the potential format features of the sampler {YCbCr} conversion do not support VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, chromaFilter must not be VK_FILTER_LINEAR" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-format-parameter", + "text": " format must be a valid VkFormat value" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-parameter", + "text": " ycbcrModel must be a valid VkSamplerYcbcrModelConversion value" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrRange-parameter", + "text": " ycbcrRange must be a valid VkSamplerYcbcrRange value" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-components-parameter", + "text": " components must be a valid VkComponentMapping structure" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-xChromaOffset-parameter", + "text": " xChromaOffset must be a valid VkChromaLocation value" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-yChromaOffset-parameter", + "text": " yChromaOffset must be a valid VkChromaLocation value" + }, + { + "vuid": "VUID-VkSamplerYcbcrConversionCreateInfo-chromaFilter-parameter", + "text": " chromaFilter must be a valid VkFilter value" + } + ] + }, + "vkDestroySamplerYcbcrConversion": { + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkDestroySamplerYcbcrConversion-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parameter", + "text": " If ycbcrConversion is not VK_NULL_HANDLE, ycbcrConversion must be a valid VkSamplerYcbcrConversion handle" + }, + { + "vuid": "VUID-vkDestroySamplerYcbcrConversion-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parent", + "text": " If ycbcrConversion is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "VkSamplerCustomBorderColorCreateInfoEXT": { + "(VK_EXT_custom_border_color)": [ + { + "vuid": "VUID-VkSamplerCustomBorderColorCreateInfoEXT-format-04013", + "text": " If provided format is not VK_FORMAT_UNDEFINED then the VkSamplerCreateInfo::borderColor type must match the sampled type of the provided format, as shown in the SPIR-V Sampled Type column of the Interpretation of Numeric Format table" + }, + { + "vuid": "VUID-VkSamplerCustomBorderColorCreateInfoEXT-format-04014", + "text": " If the customBorderColorWithoutFormat feature is not enabled then format must not be VK_FORMAT_UNDEFINED" + }, + { + "vuid": "VUID-VkSamplerCustomBorderColorCreateInfoEXT-format-04015", + "text": " If the sampler is used to sample an image view of VK_FORMAT_B4G4R4A4_UNORM_PACK16, VK_FORMAT_B5G6R5_UNORM_PACK16, or VK_FORMAT_B5G5R5A1_UNORM_PACK16 format then format must not be VK_FORMAT_UNDEFINED" + }, + { + "vuid": "VUID-VkSamplerCustomBorderColorCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkSamplerCustomBorderColorCreateInfoEXT-format-parameter", + "text": " format must be a valid VkFormat value" + } + ] + }, + "VkSamplerBorderColorComponentMappingCreateInfoEXT": { + "(VK_EXT_border_color_swizzle)": [ + { + "vuid": "VUID-VkSamplerBorderColorComponentMappingCreateInfoEXT-borderColorSwizzle-06437", + "text": " The borderColorSwizzle feature must be enabled." + } + ] + }, + "vkCreateDescriptorSetLayout": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateDescriptorSetLayout-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + }, + { + "vuid": "VUID-vkCreateDescriptorSetLayout-device-05089", + "text": " The number of descriptor set layout bindings currently allocated from device across all slink:VkDescriptorSetLayout objects plus pname:pCreateInfo->bindingCount must be less than or equal to the total number of descriptor set layout bindings requested via VkDeviceObjectReservationCreateInfo::pname:descriptorSetLayoutBindingRequestCount specified when device was created" + } + ], + "core": [ + { + "vuid": "VUID-vkCreateDescriptorSetLayout-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateDescriptorSetLayout-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkDescriptorSetLayoutCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateDescriptorSetLayout-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateDescriptorSetLayout-pSetLayout-parameter", + "text": " pSetLayout must be a valid pointer to a VkDescriptorSetLayout handle" + } + ] + }, + "VkDescriptorSetLayoutCreateInfo": { + "core": [ + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-binding-00279", + "text": " The VkDescriptorSetLayoutBinding::binding members of the elements of the pBindings array must each have different values" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkDescriptorSetLayoutBindingFlagsCreateInfo" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkDescriptorSetLayoutCreateFlagBits values" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-pBindings-parameter", + "text": " If bindingCount is not 0, pBindings must be a valid pointer to an array of bindingCount valid VkDescriptorSetLayoutBinding structures" + } + ], + "(VK_KHR_push_descriptor)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-00280", + "text": " If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then all elements of pBindings must not have a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-00281", + "text": " If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then the total number of elements of all bindings must be less than or equal to VkPhysicalDevicePushDescriptorPropertiesKHR::maxPushDescriptors" + } + ], + "(VK_KHR_push_descriptor)+(VK_EXT_inline_uniform_block)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-02208", + "text": " If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then all elements of pBindings must not have a descriptorType of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT" + } + ], + "(VK_KHR_push_descriptor)+(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-04590", + "text": " If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, flags must not contain VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-04591", + "text": " If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, pBindings must not have a descriptorType of VK_DESCRIPTOR_TYPE_MUTABLE_VALVE" + } + ], + "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-03000", + "text": " If any binding has the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT bit set, flags must include VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-descriptorType-03001", + "text": " If any binding has the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT bit set, then all bindings must not have descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC" + } + ], + "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)+(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-04592", + "text": " If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, flags must not contain VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE" + } + ], + "(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-descriptorType-04593", + "text": " If any binding has a descriptorType of VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, then a VkMutableDescriptorTypeCreateInfoVALVE must be present in the pNext chain" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-descriptorType-04594", + "text": " If a binding has a descriptorType value of VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, then pImmutableSamplers must be NULL" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-mutableDescriptorType-04595", + "text": " If VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE::mutableDescriptorType is not enabled, pBindings must not contain a descriptorType of VK_DESCRIPTOR_TYPE_MUTABLE_VALVE" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-flags-04596", + "text": " If flags contains VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE, VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE::mutableDescriptorType must be enabled" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-bindingCount-05011", + "text": " bindingCount must be less than or equal to maxDescriptorSetLayoutBindings" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutCreateInfo-descriptorCount-05071", + "text": " The sum of descriptorCount over all bindings in pBindings that have descriptorType of VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER and pImmutableSamplers not equal to NULL must be less than or equal to VkDeviceObjectReservationCreateInfo::maxImmutableSamplersPerDescriptorSetLayout" + } + ] + }, + "VkMutableDescriptorTypeListVALVE": { + "(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkMutableDescriptorTypeListVALVE-descriptorTypeCount-04597", + "text": " descriptorTypeCount must not be 0 if the corresponding binding is of VK_DESCRIPTOR_TYPE_MUTABLE_VALVE" + }, + { + "vuid": "VUID-VkMutableDescriptorTypeListVALVE-pDescriptorTypes-04598", + "text": " pDescriptorTypes must be a valid pointer to an array of descriptorTypeCount valid, unique VkDescriptorType values if the given binding is of VK_DESCRIPTOR_TYPE_MUTABLE_VALVE type" + }, + { + "vuid": "VUID-VkMutableDescriptorTypeListVALVE-descriptorTypeCount-04599", + "text": " descriptorTypeCount must be 0 if the corresponding binding is not of VK_DESCRIPTOR_TYPE_MUTABLE_VALVE" + }, + { + "vuid": "VUID-VkMutableDescriptorTypeListVALVE-pDescriptorTypes-04600", + "text": " pDescriptorTypes must not contain VK_DESCRIPTOR_TYPE_MUTABLE_VALVE" + }, + { + "vuid": "VUID-VkMutableDescriptorTypeListVALVE-pDescriptorTypes-04601", + "text": " pDescriptorTypes must not contain VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC" + }, + { + "vuid": "VUID-VkMutableDescriptorTypeListVALVE-pDescriptorTypes-04602", + "text": " pDescriptorTypes must not contain VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC" + } + ], + "(VK_VALVE_mutable_descriptor_type)+(VK_EXT_inline_uniform_block)": [ + { + "vuid": "VUID-VkMutableDescriptorTypeListVALVE-pDescriptorTypes-04603", + "text": " pDescriptorTypes must not contain VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT" + } + ] + }, + "VkDescriptorSetLayoutBinding": { + "core": [ + { + "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorType-00282", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and descriptorCount is not 0 and pImmutableSamplers is not NULL, pImmutableSamplers must be a valid pointer to an array of descriptorCount valid VkSampler handles" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorCount-00283", + "text": " If descriptorCount is not 0, stageFlags must be a valid combination of VkShaderStageFlagBits values" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorType-01510", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT and descriptorCount is not 0, then stageFlags must be 0 or VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorType-parameter", + "text": " descriptorType must be a valid VkDescriptorType value" + } + ], + "(VK_EXT_inline_uniform_block)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorType-04604", + "text": " If the inlineUniformBlock feature is not enabled, descriptorType must not be VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorType-02209", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT then descriptorCount must be a multiple of 4" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorType-02210", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT then descriptorCount must be less than or equal to VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxInlineUniformBlockSize" + } + ], + "(VK_EXT_custom_border_color)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutBinding-pImmutableSamplers-04009", + "text": " The sampler objects indicated by pImmutableSamplers must not have a borderColor with one of the values VK_BORDER_COLOR_FLOAT_CUSTOM_EXT or VK_BORDER_COLOR_INT_CUSTOM_EXT" + } + ], + "(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutBinding-descriptorType-04605", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, then pImmutableSamplers must be NULL" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutBinding-binding-05012", + "text": " binding must be less than the value of VkDeviceObjectReservationCreateInfo::descriptorSetLayoutBindingLimit provided when the device was created" + } + ] + }, + "VkDescriptorSetLayoutBindingFlagsCreateInfo": { + "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-bindingCount-03002", + "text": " If bindingCount is not zero, bindingCount must equal VkDescriptorSetLayoutCreateInfo::bindingCount" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004", + "text": " If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingUniformBufferUpdateAfterBind-03005", + "text": " If VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingUniformBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingSampledImageUpdateAfterBind-03006", + "text": " If VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingSampledImageUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, or VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingStorageImageUpdateAfterBind-03007", + "text": " If VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingStorageImageUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingStorageBufferUpdateAfterBind-03008", + "text": " If VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingStorageBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingUniformTexelBufferUpdateAfterBind-03009", + "text": " If VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingUniformTexelBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingStorageTexelBufferUpdateAfterBind-03010", + "text": " If VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingStorageTexelBufferUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-None-03011", + "text": " All bindings with descriptor type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingUpdateUnusedWhilePending-03012", + "text": " If VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingUpdateUnusedWhilePending is not enabled, all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingPartiallyBound-03013", + "text": " If VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingPartiallyBound is not enabled, all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingVariableDescriptorCount-03014", + "text": " If VkPhysicalDeviceDescriptorIndexingFeatures::descriptorBindingVariableDescriptorCount is not enabled, all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03015", + "text": " If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, that element’s descriptorType must not be VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-parameter", + "text": " If bindingCount is not 0, pBindingFlags must be a valid pointer to an array of bindingCount valid combinations of VkDescriptorBindingFlagBits values" + } + ], + "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)+(VK_KHR_push_descriptor)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-flags-03003", + "text": " If VkDescriptorSetLayoutCreateInfo::flags includes VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, then all elements of pBindingFlags must not include VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT, VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT, or VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT" + } + ], + "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)+(VK_EXT_inline_uniform_block)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingInlineUniformBlockUpdateAfterBind-02211", + "text": " If VkPhysicalDeviceInlineUniformBlockFeaturesEXT::descriptorBindingInlineUniformBlockUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT" + } + ], + "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)+(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingAccelerationStructureUpdateAfterBind-03570", + "text": " If VkPhysicalDeviceAccelerationStructureFeaturesKHR::descriptorBindingAccelerationStructureUpdateAfterBind is not enabled, all bindings with descriptor type VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR or VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT" + } + ] + }, + "vkGetDescriptorSetLayoutSupport": { + "(VK_VERSION_1_1,VK_KHR_maintenance3)": [ + { + "vuid": "VUID-vkGetDescriptorSetLayoutSupport-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetDescriptorSetLayoutSupport-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkDescriptorSetLayoutCreateInfo structure" + }, + { + "vuid": "VUID-vkGetDescriptorSetLayoutSupport-pSupport-parameter", + "text": " pSupport must be a valid pointer to a VkDescriptorSetLayoutSupport structure" + } + ] + }, + "VkDescriptorSetLayoutSupport": { + "(VK_VERSION_1_1,VK_KHR_maintenance3)": [ + { + "vuid": "VUID-VkDescriptorSetLayoutSupport-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutSupport-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkDescriptorSetVariableDescriptorCountLayoutSupport" + }, + { + "vuid": "VUID-VkDescriptorSetLayoutSupport-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + } + ] + }, + "VkDescriptorSetVariableDescriptorCountLayoutSupport": { + "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkDescriptorSetVariableDescriptorCountLayoutSupport-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT" + } + ] + }, + "vkDestroyDescriptorSetLayout": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00284", + "text": " If VkAllocationCallbacks were provided when descriptorSetLayout was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00285", + "text": " If no VkAllocationCallbacks were provided when descriptorSetLayout was created, pAllocator must be NULL" + } + ], + "core": [ + { + "vuid": "VUID-vkDestroyDescriptorSetLayout-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-parameter", + "text": " If descriptorSetLayout is not VK_NULL_HANDLE, descriptorSetLayout must be a valid VkDescriptorSetLayout handle" + }, + { + "vuid": "VUID-vkDestroyDescriptorSetLayout-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-parent", + "text": " If descriptorSetLayout is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCreatePipelineLayout": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreatePipelineLayout-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "core": [ + { + "vuid": "VUID-vkCreatePipelineLayout-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreatePipelineLayout-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkPipelineLayoutCreateInfo structure" + }, + { + "vuid": "VUID-vkCreatePipelineLayout-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreatePipelineLayout-pPipelineLayout-parameter", + "text": " pPipelineLayout must be a valid pointer to a VkPipelineLayout handle" + } + ] + }, + "VkPipelineLayoutCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-setLayoutCount-00286", + "text": " setLayoutCount must be less than or equal to VkPhysicalDeviceLimits::maxBoundDescriptorSets" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pPushConstantRanges-00292", + "text": " Any two elements of pPushConstantRanges must not include the same stage in stageFlags" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-parameter", + "text": " If setLayoutCount is not 0, pSetLayouts must be a valid pointer to an array of setLayoutCount valid VkDescriptorSetLayout handles" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pPushConstantRanges-parameter", + "text": " If pushConstantRangeCount is not 0, pPushConstantRanges must be a valid pointer to an array of pushConstantRangeCount valid VkPushConstantRange structures" + } + ], + "!(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00287", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSamplers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00288", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER and VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorUniformBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00289", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER and VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00290", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSampledImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00291", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible to any shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01676", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorInputAttachments" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01677", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSamplers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01678", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01679", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffersDynamic" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01680", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01681", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffersDynamic" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01682", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSampledImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01683", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-01684", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetInputAttachments" + } + ], + "!(VK_VERSION_1_2,VK_EXT_descriptor_indexing)+(VK_EXT_inline_uniform_block)": [ + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-02212", + "text": " The total number of bindings with a descriptorType of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxPerStageDescriptorInlineUniformBlocks" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-02213", + "text": " The total number of bindings with a descriptorType of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxDescriptorSetInlineUniformBlocks" + } + ], + "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03016", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSamplers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03017", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER and VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorUniformBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03018", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER and VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03019", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorSampledImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03020", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorStorageImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03021", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxPerStageDescriptorInputAttachments" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03022", + "text": " The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxPerStageDescriptorUpdateAfterBindSamplers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03023", + "text": " The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER and VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxPerStageDescriptorUpdateAfterBindUniformBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03024", + "text": " The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER and VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxPerStageDescriptorUpdateAfterBindStorageBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03025", + "text": " The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxPerStageDescriptorUpdateAfterBindSampledImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03026", + "text": " The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxPerStageDescriptorUpdateAfterBindStorageImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03027", + "text": " The total number of descriptors with a descriptorType of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxPerStageDescriptorUpdateAfterBindInputAttachments" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03028", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSamplers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03029", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03030", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetUniformBuffersDynamic" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03031", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03032", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageBuffersDynamic" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03033", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetSampledImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03034", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetStorageImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03035", + "text": " The total number of descriptors in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceLimits::maxDescriptorSetInputAttachments" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03036", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_SAMPLER and VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxDescriptorSetUpdateAfterBindSamplers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03037", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxDescriptorSetUpdateAfterBindUniformBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03038", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxDescriptorSetUpdateAfterBindUniformBuffersDynamic" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03039", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxDescriptorSetUpdateAfterBindStorageBuffers" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03040", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxDescriptorSetUpdateAfterBindStorageBuffersDynamic" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03041", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxDescriptorSetUpdateAfterBindSampledImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03042", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxDescriptorSetUpdateAfterBindStorageImages" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-03043", + "text": " The total number of descriptors of the type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceDescriptorIndexingProperties::maxDescriptorSetUpdateAfterBindInputAttachments" + } + ], + "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)+(VK_EXT_inline_uniform_block)": [ + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-02214", + "text": " The total number of bindings in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxPerStageDescriptorInlineUniformBlocks" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-02215", + "text": " The total number of bindings with a descriptorType of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-02216", + "text": " The total number of bindings in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxDescriptorSetInlineUniformBlocks" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-02217", + "text": " The total number of bindings with a descriptorType of VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceInlineUniformBlockPropertiesEXT::maxDescriptorSetUpdateAfterBindInlineUniformBlocks" + } + ], + "(VK_KHR_push_descriptor)": [ + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-00293", + "text": " pSetLayouts must not contain more than one descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR set" + } + ], + "(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03571", + "text": " The total number of bindings in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceAccelerationStructurePropertiesKHR::maxPerStageDescriptorAccelerationStructures" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03572", + "text": " The total number of bindings with a descriptorType of VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR accessible to any given shader stage across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceAccelerationStructurePropertiesKHR::maxPerStageDescriptorUpdateAfterBindAccelerationStructures" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03573", + "text": " The total number of bindings in descriptor set layouts created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set with a descriptorType of VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceAccelerationStructurePropertiesKHR::maxDescriptorSetAccelerationStructures" + }, + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03574", + "text": " The total number of bindings with a descriptorType of VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceAccelerationStructurePropertiesKHR::maxDescriptorSetUpdateAfterBindAccelerationStructures" + } + ], + "(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-02381", + "text": " The total number of bindings with a descriptorType of VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV accessible across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxDescriptorSetAccelerationStructures" + } + ], + "(VK_EXT_fragment_density_map2)": [ + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pImmutableSamplers-03566", + "text": " The total number of pImmutableSamplers created with flags containing VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT or VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT across all shader stages and across all elements of pSetLayouts must be less than or equal to VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::maxDescriptorSetSubsampledSamplers" + } + ], + "(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-04606", + "text": " Any element of pSetLayouts must not have been created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE bit set" + } + ] + }, + "VkPushConstantRange": { + "core": [ + { + "vuid": "VUID-VkPushConstantRange-offset-00294", + "text": " offset must be less than VkPhysicalDeviceLimits::maxPushConstantsSize" + }, + { + "vuid": "VUID-VkPushConstantRange-offset-00295", + "text": " offset must be a multiple of 4" + }, + { + "vuid": "VUID-VkPushConstantRange-size-00296", + "text": " size must be greater than 0" + }, + { + "vuid": "VUID-VkPushConstantRange-size-00297", + "text": " size must be a multiple of 4" + }, + { + "vuid": "VUID-VkPushConstantRange-size-00298", + "text": " size must be less than or equal to VkPhysicalDeviceLimits::maxPushConstantsSize minus offset" + }, + { + "vuid": "VUID-VkPushConstantRange-stageFlags-parameter", + "text": " stageFlags must be a valid combination of VkShaderStageFlagBits values" + }, + { + "vuid": "VUID-VkPushConstantRange-stageFlags-requiredbitmask", + "text": " stageFlags must not be 0" + } + ] + }, + "vkDestroyPipelineLayout": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyPipelineLayout-pipelineLayout-00299", + "text": " If VkAllocationCallbacks were provided when pipelineLayout was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyPipelineLayout-pipelineLayout-00300", + "text": " If no VkAllocationCallbacks were provided when pipelineLayout was created, pAllocator must be NULL" + } + ], + "core": [ + { + "vuid": "VUID-vkDestroyPipelineLayout-pipelineLayout-02004", + "text": " pipelineLayout must not have been passed to any vkCmd* command for any command buffers that are still in the recording state when vkDestroyPipelineLayout is called" + }, + { + "vuid": "VUID-vkDestroyPipelineLayout-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyPipelineLayout-pipelineLayout-parameter", + "text": " If pipelineLayout is not VK_NULL_HANDLE, pipelineLayout must be a valid VkPipelineLayout handle" + }, + { + "vuid": "VUID-vkDestroyPipelineLayout-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyPipelineLayout-pipelineLayout-parent", + "text": " If pipelineLayout is a valid handle, it must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCreateDescriptorPool": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateDescriptorPool-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "core": [ + { + "vuid": "VUID-vkCreateDescriptorPool-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateDescriptorPool-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkDescriptorPoolCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateDescriptorPool-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateDescriptorPool-pDescriptorPool-parameter", + "text": " pDescriptorPool must be a valid pointer to a VkDescriptorPool handle" + } + ] + }, + "VkDescriptorPoolCreateInfo": { + "core": [ + { + "vuid": "VUID-VkDescriptorPoolCreateInfo-maxSets-00301", + "text": " maxSets must be greater than 0" + }, + { + "vuid": "VUID-VkDescriptorPoolCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO" + }, + { + "vuid": "VUID-VkDescriptorPoolCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDescriptorPoolCreateInfo-flags-parameter", + "text": " flags must be a valid combination of VkDescriptorPoolCreateFlagBits values" + }, + { + "vuid": "VUID-VkDescriptorPoolCreateInfo-pPoolSizes-parameter", + "text": " pPoolSizes must be a valid pointer to an array of poolSizeCount valid VkDescriptorPoolSize structures" + }, + { + "vuid": "VUID-VkDescriptorPoolCreateInfo-poolSizeCount-arraylength", + "text": " poolSizeCount must be greater than 0" + } + ], + "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)+(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkDescriptorPoolCreateInfo-flags-04607", + "text": " If flags has the VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE bit set, then the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT bit must not be set" + } + ], + "(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkDescriptorPoolCreateInfo-mutableDescriptorType-04608", + "text": " If VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE::mutableDescriptorType is not enabled, pPoolSizes must not contain a descriptorType of VK_DESCRIPTOR_TYPE_MUTABLE_VALVE" + }, + { + "vuid": "VUID-VkDescriptorPoolCreateInfo-flags-04609", + "text": " If flags has the VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE bit set, VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE::mutableDescriptorType must be enabled" + }, + { + "vuid": "VUID-VkDescriptorPoolCreateInfo-pPoolSizes-04787", + "text": " If pPoolSizes contains a descriptorType of VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, any other VK_DESCRIPTOR_TYPE_MUTABLE_VALVE element in pPoolSizes must not have sets of supported descriptor types which partially overlap" + } + ] + }, + "VkDescriptorPoolSize": { + "core": [ + { + "vuid": "VUID-VkDescriptorPoolSize-descriptorCount-00302", + "text": " descriptorCount must be greater than 0" + }, + { + "vuid": "VUID-VkDescriptorPoolSize-type-parameter", + "text": " type must be a valid VkDescriptorType value" + } + ], + "(VK_EXT_inline_uniform_block)": [ + { + "vuid": "VUID-VkDescriptorPoolSize-type-02218", + "text": " If type is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT then descriptorCount must be a multiple of 4" + } + ] + }, + "vkDestroyDescriptorPool": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyDescriptorPool-descriptorPool-00303", + "text": " All submitted commands that refer to descriptorPool (via any allocated descriptor sets) must have completed execution" + }, + { + "vuid": "VUID-vkDestroyDescriptorPool-descriptorPool-00304", + "text": " If VkAllocationCallbacks were provided when descriptorPool was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyDescriptorPool-descriptorPool-00305", + "text": " If no VkAllocationCallbacks were provided when descriptorPool was created, pAllocator must be NULL" + } + ] + }, + "vkAllocateDescriptorSets": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkAllocateDescriptorSets-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "core": [ + { + "vuid": "VUID-vkAllocateDescriptorSets-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkAllocateDescriptorSets-pAllocateInfo-parameter", + "text": " pAllocateInfo must be a valid pointer to a valid VkDescriptorSetAllocateInfo structure" + }, + { + "vuid": "VUID-vkAllocateDescriptorSets-pDescriptorSets-parameter", + "text": " pDescriptorSets must be a valid pointer to an array of pAllocateInfo->descriptorSetCount VkDescriptorSet handles" + }, + { + "vuid": "VUID-vkAllocateDescriptorSets-pAllocateInfo::descriptorSetCount-arraylength", + "text": " pAllocateInfo->descriptorSetCount must be greater than 0" + } + ] + }, + "VkDescriptorSetAllocateInfo": { + "!(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-descriptorSetCount-00306", + "text": " descriptorSetCount must not be greater than the number of sets that are currently available for allocation in descriptorPool" + }, + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-descriptorPool-00307", + "text": " descriptorPool must have enough free descriptor capacity remaining to allocate the descriptor sets of the specified layouts" + } + ], + "(VK_KHR_push_descriptor)": [ + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-pSetLayouts-00308", + "text": " Each element of pSetLayouts must not have been created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR set" + } + ], + "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-pSetLayouts-03044", + "text": " If any element of pSetLayouts was created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT bit set, descriptorPool must have been created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT flag set" + } + ], + "(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-pSetLayouts-04610", + "text": " If any element of pSetLayouts was created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE bit set, descriptorPool must have been created with the VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE flag set" + } + ], + "core": [ + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO" + }, + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkDescriptorSetVariableDescriptorCountAllocateInfo" + }, + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-descriptorPool-parameter", + "text": " descriptorPool must be a valid VkDescriptorPool handle" + }, + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-pSetLayouts-parameter", + "text": " pSetLayouts must be a valid pointer to an array of descriptorSetCount valid VkDescriptorSetLayout handles" + }, + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-descriptorSetCount-arraylength", + "text": " descriptorSetCount must be greater than 0" + }, + { + "vuid": "VUID-VkDescriptorSetAllocateInfo-commonparent", + "text": " Both of descriptorPool, and the elements of pSetLayouts must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "VkDescriptorSetVariableDescriptorCountAllocateInfo": { + "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkDescriptorSetVariableDescriptorCountAllocateInfo-descriptorSetCount-03045", + "text": " If descriptorSetCount is not zero, descriptorSetCount must equal VkDescriptorSetAllocateInfo::descriptorSetCount" + }, + { + "vuid": "VUID-VkDescriptorSetVariableDescriptorCountAllocateInfo-pSetLayouts-03046", + "text": " If VkDescriptorSetAllocateInfo::pSetLayouts[i] has a variable descriptor count binding, then pDescriptorCounts[i] must be less than or equal to the descriptor count specified for that binding when the descriptor set layout was created" + }, + { + "vuid": "VUID-VkDescriptorSetVariableDescriptorCountAllocateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO" + }, + { + "vuid": "VUID-VkDescriptorSetVariableDescriptorCountAllocateInfo-pDescriptorCounts-parameter", + "text": " If descriptorSetCount is not 0, pDescriptorCounts must be a valid pointer to an array of descriptorSetCount uint32_t values" + } + ] + }, + "vkFreeDescriptorSets": { + "core": [ + { + "vuid": "VUID-vkFreeDescriptorSets-pDescriptorSets-00309", + "text": " All submitted commands that refer to any element of pDescriptorSets must have completed execution" + }, + { + "vuid": "VUID-vkFreeDescriptorSets-pDescriptorSets-00310", + "text": " pDescriptorSets must be a valid pointer to an array of descriptorSetCount VkDescriptorSet handles, each element of which must either be a valid handle or VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkFreeDescriptorSets-descriptorPool-00312", + "text": " descriptorPool must have been created with the VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT flag" + }, + { + "vuid": "VUID-vkFreeDescriptorSets-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkFreeDescriptorSets-descriptorPool-parameter", + "text": " descriptorPool must be a valid VkDescriptorPool handle" + }, + { + "vuid": "VUID-vkFreeDescriptorSets-descriptorSetCount-arraylength", + "text": " descriptorSetCount must be greater than 0" + }, + { + "vuid": "VUID-vkFreeDescriptorSets-descriptorPool-parent", + "text": " descriptorPool must have been created, allocated, or retrieved from device" + }, + { + "vuid": "VUID-vkFreeDescriptorSets-pDescriptorSets-parent", + "text": " Each element of pDescriptorSets that is a valid handle must have been created, allocated, or retrieved from descriptorPool" + } + ] + }, + "vkResetDescriptorPool": { + "core": [ + { + "vuid": "VUID-vkResetDescriptorPool-descriptorPool-00313", + "text": " All uses of descriptorPool (via any allocated descriptor sets) must have completed execution" + }, + { + "vuid": "VUID-vkResetDescriptorPool-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkResetDescriptorPool-descriptorPool-parameter", + "text": " descriptorPool must be a valid VkDescriptorPool handle" + }, + { + "vuid": "VUID-vkResetDescriptorPool-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-vkResetDescriptorPool-descriptorPool-parent", + "text": " descriptorPool must have been created, allocated, or retrieved from device" + } + ] + }, + "vkUpdateDescriptorSets": { + "core": [ + { + "vuid": "VUID-vkUpdateDescriptorSets-pDescriptorWrites-06236", + "text": " For each element i where pDescriptorWrites[i].descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, elements of the pTexelBufferView member of pDescriptorWrites[i] must have been created on device" + }, + { + "vuid": "VUID-vkUpdateDescriptorSets-pDescriptorWrites-06237", + "text": " For each element i where pDescriptorWrites[i].descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the buffer member of any element of the pBufferInfo member of pDescriptorWrites[i] must have been created on device" + }, + { + "vuid": "VUID-vkUpdateDescriptorSets-pDescriptorWrites-06238", + "text": " For each element i where pDescriptorWrites[i].descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and dstSet was not allocated with a layout that included immutable samplers for dstBinding with descriptorType, the sampler member of any element of the pImageInfo member of pDescriptorWrites[i] must have been created on device" + }, + { + "vuid": "VUID-vkUpdateDescriptorSets-pDescriptorWrites-06239", + "text": " For each element i where pDescriptorWrites[i].descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER the imageView member of any element of pDescriptorWrites[i] must have been created on device" + }, + { + "vuid": "VUID-vkUpdateDescriptorSets-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkUpdateDescriptorSets-pDescriptorWrites-parameter", + "text": " If descriptorWriteCount is not 0, pDescriptorWrites must be a valid pointer to an array of descriptorWriteCount valid VkWriteDescriptorSet structures" + }, + { + "vuid": "VUID-vkUpdateDescriptorSets-pDescriptorCopies-parameter", + "text": " If descriptorCopyCount is not 0, pDescriptorCopies must be a valid pointer to an array of descriptorCopyCount valid VkCopyDescriptorSet structures" + } + ], + "(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkUpdateDescriptorSets-pDescriptorWrites-06240", + "text": " For each element i where pDescriptorWrites[i].descriptorType is VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, elements of the pAccelerationStructures member of a VkWriteDescriptorSetAccelerationStructureKHR structure in the pNext chain of pDescriptorWrites[i] must have been created on device" + } + ], + "(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-vkUpdateDescriptorSets-pDescriptorWrites-06241", + "text": " For each element i where pDescriptorWrites[i].descriptorType is VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV, elements of the pAccelerationStructures member of a VkWriteDescriptorSetAccelerationStructureNV structure in the pNext chain of pDescriptorWrites[i] must have been created on device" + } + ], + "!(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-vkUpdateDescriptorSets-dstSet-00314", + "text": " The dstSet member of each element of pDescriptorWrites or pDescriptorCopies must not be used by any command that was recorded to a command buffer which is in the pending state" + } + ], + "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-vkUpdateDescriptorSets-None-03047", + "text": " Descriptor bindings updated by this command which were created without the VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT or VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT bits set must not be used by any command that was recorded to a command buffer which is in the pending state" + } + ] + }, + "VkWriteDescriptorSet": { + "core": [ + { + "vuid": "VUID-VkWriteDescriptorSet-dstBinding-00315", + "text": " dstBinding must be less than or equal to the maximum value of binding of all VkDescriptorSetLayoutBinding structures specified when dstSet’s descriptor set layout was created" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-dstBinding-00316", + "text": " dstBinding must be a binding with a non-zero descriptorCount" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorCount-00317", + "text": " All consecutive bindings updated via a single VkWriteDescriptorSet structure, except those with a descriptorCount of zero, must have identical descriptorType and stageFlags" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorCount-00318", + "text": " All consecutive bindings updated via a single VkWriteDescriptorSet structure, except those with a descriptorCount of zero, must all either use immutable samplers or must all not use immutable samplers" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00319", + "text": " descriptorType must match the type of dstBinding within dstSet" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-dstSet-00320", + "text": " dstSet must be a valid VkDescriptorSet handle" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-dstArrayElement-00321", + "text": " The sum of dstArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding specified by dstBinding, and all applicable consecutive bindings, as described by consecutive binding updates" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00322", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, pImageInfo must be a valid pointer to an array of descriptorCount valid VkDescriptorImageInfo structures" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-02994", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, each element of pTexelBufferView must be either a valid VkBufferView handle or VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-02995", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER and the nullDescriptor feature is not enabled, each element of pTexelBufferView must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00324", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, pBufferInfo must be a valid pointer to an array of descriptorCount valid VkDescriptorBufferInfo structures" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00325", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and dstSet was not allocated with a layout that included immutable samplers for dstBinding with descriptorType, the sampler member of each element of pImageInfo must be a valid VkSampler object" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-02996", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView member of each element of pImageInfo must be either a valid VkImageView handle or VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-02997", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT and the nullDescriptor feature is not enabled, the imageView member of each element of pImageInfo must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00327", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the offset member of each element of pBufferInfo must be a multiple of VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00328", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the offset member of each element of pBufferInfo must be a multiple of VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00329", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, and the buffer member of any element of pBufferInfo is the handle of a non-sparse buffer, then that buffer must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00330", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the buffer member of each element of pBufferInfo must have been created with VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT set" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00331", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the buffer member of each element of pBufferInfo must have been created with VK_BUFFER_USAGE_STORAGE_BUFFER_BIT set" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00332", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the range member of each element of pBufferInfo, or the effective range if range is VK_WHOLE_SIZE, must be less than or equal to VkPhysicalDeviceLimits::maxUniformBufferRange" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00333", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the range member of each element of pBufferInfo, or the effective range if range is VK_WHOLE_SIZE, must be less than or equal to VkPhysicalDeviceLimits::maxStorageBufferRange" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00334", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, the VkBuffer that each element of pTexelBufferView was created from must have been created with VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT set" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00335", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, the VkBuffer that each element of pTexelBufferView was created from must have been created with VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT set" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00336", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView member of each element of pImageInfo must have been created with the identity swizzle" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00337", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_SAMPLED_BIT set" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-04149", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE the imageLayout member of each element of pImageInfo must be a member of the list given in Sampled Image" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-04150", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER the imageLayout member of each element of pImageInfo must be a member of the list given in Combined Image Sampler" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-04151", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT the imageLayout member of each element of pImageInfo must be a member of the list given in Input Attachment" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-04152", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE the imageLayout member of each element of pImageInfo must be a member of the list given in Storage Image" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00338", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00339", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_STORAGE_BIT set" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-02752", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER, then dstSet must not have been allocated with a layout that included immutable samplers for dstBinding" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-parameter", + "text": " descriptorType must be a valid VkDescriptorType value" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorCount-arraylength", + "text": " descriptorCount must be greater than 0" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-commonparent", + "text": " Both of dstSet, and the elements of pTexelBufferView that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_EXT_inline_uniform_block)": [ + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-02219", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, dstArrayElement must be an integer multiple of 4" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-02220", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, descriptorCount must be an integer multiple of 4" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-02221", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, the pNext chain must include a VkWriteDescriptorSetInlineUniformBlockEXT structure whose dataSize member equals descriptorCount" + } + ], + "(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-02382", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, the pNext chain must include a VkWriteDescriptorSetAccelerationStructureKHR structure whose accelerationStructureCount member equals descriptorCount" + } + ], + "(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-03817", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV, the pNext chain must include a VkWriteDescriptorSetAccelerationStructureNV structure whose accelerationStructureCount member equals descriptorCount" + } + ], + "(VK_VULKAN_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-01946", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, then the imageView member of each pImageInfo element must have been created without a VkSamplerYcbcrConversionInfo structure in its pNext chain" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-02738", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and if any element of pImageInfo has a imageView member that was created with a VkSamplerYcbcrConversionInfo structure in its pNext chain, then dstSet must have been allocated with a layout that included immutable samplers for dstBinding, and the corresponding immutable sampler must have been created with an identically defined VkSamplerYcbcrConversionInfo object" + }, + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-01948", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and dstSet was allocated with a layout that included immutable samplers for dstBinding, then the imageView member of each element of pImageInfo which corresponds to an immutable sampler that enables sampler {YCbCr} conversion must have been created with a VkSamplerYcbcrConversionInfo structure in its pNext chain with an identically defined VkSamplerYcbcrConversionInfo to the corresponding immutable sampler" + } + ], + "(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkWriteDescriptorSet-dstSet-04611", + "text": " If the VkDescriptorSetLayoutBinding for dstSet at dstBinding is VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, the new active descriptor type descriptorType must exist in the corresponding pMutableDescriptorTypeLists list for dstBinding" + } + ], + "(VK_EXT_image_view_min_lod)": [ + { + "vuid": "VUID-VkWriteDescriptorSet-descriptorType-06450", + "text": " If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView member of each element of pImageInfo must have either been created without a VkImageViewMinLodCreateInfoEXT present in the pNext chain or with a VkImageViewMinLodCreateInfoEXT::minLod of 0.0" + } + ] + }, + "VkDescriptorBufferInfo": { + "core": [ + { + "vuid": "VUID-VkDescriptorBufferInfo-offset-00340", + "text": " offset must be less than the size of buffer" + }, + { + "vuid": "VUID-VkDescriptorBufferInfo-range-00341", + "text": " If range is not equal to VK_WHOLE_SIZE, range must be greater than 0" + }, + { + "vuid": "VUID-VkDescriptorBufferInfo-range-00342", + "text": " If range is not equal to VK_WHOLE_SIZE, range must be less than or equal to the size of buffer minus offset" + }, + { + "vuid": "VUID-VkDescriptorBufferInfo-buffer-02998", + "text": " If the nullDescriptor feature is not enabled, buffer must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkDescriptorBufferInfo-buffer-parameter", + "text": " If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle" + } + ], + "(VK_EXT_robustness2)": [ + { + "vuid": "VUID-VkDescriptorBufferInfo-buffer-02999", + "text": " If buffer is VK_NULL_HANDLE, offset must be zero and range must be VK_WHOLE_SIZE" + } + ] + }, + "VkDescriptorImageInfo": { + "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkDescriptorImageInfo-imageView-00343", + "text": " imageView must not be 2D or 2D array image view created from a 3D image" + } + ], + "core": [ + { + "vuid": "VUID-VkDescriptorImageInfo-imageView-01976", + "text": " If imageView is created from a depth/stencil image, the aspectMask used to create the imageView must include either VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT but not both" + }, + { + "vuid": "VUID-VkDescriptorImageInfo-imageLayout-00344", + "text": " imageLayout must match the actual VkImageLayout of each subresource accessible from imageView at the time this descriptor is accessed as defined by the image layout matching rules" + }, + { + "vuid": "VUID-VkDescriptorImageInfo-commonparent", + "text": " Both of imageView, and sampler that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkDescriptorImageInfo-sampler-01564", + "text": " If sampler is used and the VkFormat of the image is a multi-planar format, the image must have been created with VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, and the aspectMask of the imageView must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or (for three-plane formats only) VK_IMAGE_ASPECT_PLANE_2_BIT" + } + ], + "(VK_KHR_portability_subset)": [ + { + "vuid": "VUID-VkDescriptorImageInfo-mutableComparisonSamplers-04450", + "text": " If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::mutableComparisonSamplers is VK_FALSE, then sampler must have been created with VkSamplerCreateInfo::compareEnable set to VK_FALSE" + } + ] + }, + "VkWriteDescriptorSetInlineUniformBlockEXT": { + "(VK_EXT_inline_uniform_block)": [ + { + "vuid": "VUID-VkWriteDescriptorSetInlineUniformBlockEXT-dataSize-02222", + "text": " dataSize must be an integer multiple of 4" + } + ] + }, + "VkWriteDescriptorSetAccelerationStructureKHR": { + "(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-VkWriteDescriptorSetAccelerationStructureKHR-accelerationStructureCount-02236", + "text": " accelerationStructureCount must be equal to descriptorCount in the extended structure" + }, + { + "vuid": "VUID-VkWriteDescriptorSetAccelerationStructureKHR-pAccelerationStructures-03579", + "text": " Each acceleration structure in pAccelerationStructures must have been created with a type of VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR or VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR" + }, + { + "vuid": "VUID-VkWriteDescriptorSetAccelerationStructureKHR-pAccelerationStructures-03580", + "text": " If the nullDescriptor feature is not enabled, each element of pAccelerationStructures must not be VK_NULL_HANDLE" + } + ] + }, + "VkWriteDescriptorSetAccelerationStructureNV": { + "(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-VkWriteDescriptorSetAccelerationStructureNV-accelerationStructureCount-03747", + "text": " accelerationStructureCount must be equal to descriptorCount in the extended structure" + }, + { + "vuid": "VUID-VkWriteDescriptorSetAccelerationStructureNV-pAccelerationStructures-03748", + "text": " Each acceleration structure in pAccelerationStructures must have been created with VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR" + }, + { + "vuid": "VUID-VkWriteDescriptorSetAccelerationStructureNV-pAccelerationStructures-03749", + "text": " If the nullDescriptor feature is not enabled, each member of pAccelerationStructures must not be VK_NULL_HANDLE" + } + ] + }, + "VkCopyDescriptorSet": { + "core": [ + { + "vuid": "VUID-VkCopyDescriptorSet-srcBinding-00345", + "text": " srcBinding must be a valid binding within srcSet" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-srcArrayElement-00346", + "text": " The sum of srcArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding specified by srcBinding, and all applicable consecutive bindings, as described by consecutive binding updates" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-dstBinding-00347", + "text": " dstBinding must be a valid binding within dstSet" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-dstArrayElement-00348", + "text": " The sum of dstArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding specified by dstBinding, and all applicable consecutive bindings, as described by consecutive binding updates" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-dstBinding-02632", + "text": " The type of dstBinding within dstSet must be equal to the type of srcBinding within srcSet" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-srcSet-00349", + "text": " If srcSet is equal to dstSet, then the source and destination ranges of descriptors must not overlap, where the ranges may include array elements from consecutive bindings as described by consecutive binding updates" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-dstBinding-02753", + "text": " If the descriptor type of the descriptor set binding specified by dstBinding is VK_DESCRIPTOR_TYPE_SAMPLER, then dstSet must not have been allocated with a layout that included immutable samplers for dstBinding" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-srcSet-parameter", + "text": " srcSet must be a valid VkDescriptorSet handle" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-dstSet-parameter", + "text": " dstSet must be a valid VkDescriptorSet handle" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-commonparent", + "text": " Both of dstSet, and srcSet must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_EXT_inline_uniform_block)": [ + { + "vuid": "VUID-VkCopyDescriptorSet-srcBinding-02223", + "text": " If the descriptor type of the descriptor set binding specified by srcBinding is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, srcArrayElement must be an integer multiple of 4" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-dstBinding-02224", + "text": " If the descriptor type of the descriptor set binding specified by dstBinding is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, dstArrayElement must be an integer multiple of 4" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-srcBinding-02225", + "text": " If the descriptor type of the descriptor set binding specified by either srcBinding or dstBinding is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, descriptorCount must be an integer multiple of 4" + } + ], + "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkCopyDescriptorSet-srcSet-01918", + "text": " If srcSet’s layout was created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT flag set, then dstSet’s layout must also have been created with the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT flag set" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-srcSet-01920", + "text": " If the descriptor pool from which srcSet was allocated was created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT flag set, then the descriptor pool from which dstSet was allocated must also have been created with the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT flag set" + } + ], + "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)+(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkCopyDescriptorSet-srcSet-04885", + "text": " If srcSet’s layout was created with neither VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT nor VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE flags set, then dstSet’s layout must have been created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT flag set" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-srcSet-04887", + "text": " If the descriptor pool from which srcSet was allocated was created with neither VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT nor VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE flags set, then the descriptor pool from which dstSet was allocated must have been created without the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT flag set" + } + ], + "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)+!(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkCopyDescriptorSet-srcSet-04886", + "text": " If srcSet’s layout was created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT flag set, then dstSet’s layout must also have been created without the VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT flag set" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-srcSet-04888", + "text": " If the descriptor pool from which srcSet was allocated was created without the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT flag set, then the descriptor pool from which dstSet was allocated must also have been created without the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT flag set" + } + ], + "(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkCopyDescriptorSet-dstSet-04612", + "text": " If VkDescriptorSetLayoutBinding for dstSet at dstBinding is VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, the new active descriptor type must exist in the corresponding pMutableDescriptorTypeLists list for dstBinding if the new active descriptor type is not VK_DESCRIPTOR_TYPE_MUTABLE_VALVE" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-srcSet-04613", + "text": " If VkDescriptorSetLayoutBinding for srcSet at srcBinding is VK_DESCRIPTOR_TYPE_MUTABLE_VALVE and the VkDescriptorSetLayoutBinding for dstSet at dstBinding is not VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, the active descriptor type for the source descriptor must match the descriptor type of dstBinding" + }, + { + "vuid": "VUID-VkCopyDescriptorSet-dstSet-04614", + "text": " If VkDescriptorSetLayoutBinding for dstSet at dstBinding is VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, and the new active descriptor type is VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, the pMutableDescriptorTypeLists for srcBinding and dstBinding must match exactly" + } + ] + }, + "VkDescriptorUpdateTemplateCreateInfo": { + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ + { + "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00350", + "text": " If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, descriptorSetLayout must be a valid VkDescriptorSetLayout handle" + } + ], + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)+(VK_KHR_push_descriptor)": [ + { + "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00351", + "text": " If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, pipelineBindPoint must be a valid VkPipelineBindPoint value" + }, + { + "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00352", + "text": " If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, pipelineLayout must be a valid VkPipelineLayout handle" + }, + { + "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-00353", + "text": " If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, set must be the unique set number in the pipeline layout that uses a descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR" + } + ], + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)+(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-VkDescriptorUpdateTemplateCreateInfo-templateType-04615", + "text": " If templateType is VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, descriptorSetLayout must not contain a binding with type VK_DESCRIPTOR_TYPE_MUTABLE_VALVE" + } + ] + }, + "VkDescriptorUpdateTemplateEntry": { + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ + { + "vuid": "VUID-VkDescriptorUpdateTemplateEntry-dstBinding-00354", + "text": " dstBinding must be a valid binding in the descriptor set layout implicitly specified when using a descriptor update template to update descriptors" + }, + { + "vuid": "VUID-VkDescriptorUpdateTemplateEntry-dstArrayElement-00355", + "text": " dstArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding implicitly specified when using a descriptor update template to update descriptors, and all applicable consecutive bindings, as described by consecutive binding updates" + } + ], + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)+(VK_EXT_inline_uniform_block)": [ + { + "vuid": "VUID-VkDescriptorUpdateTemplateEntry-descriptor-02226", + "text": " If descriptor type is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, dstArrayElement must be an integer multiple of 4" + }, + { + "vuid": "VUID-VkDescriptorUpdateTemplateEntry-descriptor-02227", + "text": " If descriptor type is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, descriptorCount must be an integer multiple of 4" + } + ] + }, + "vkDestroyDescriptorUpdateTemplate": { + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00356", + "text": " If VkAllocationCallbacks were provided when descriptorUpdateTemplate was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00357", + "text": " If no VkAllocationCallbacks were provided when descriptorUpdateTemplate was created, pAllocator must be NULL" + } + ] + }, + "vkUpdateDescriptorSetWithTemplate": { + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ + { + "vuid": "VUID-vkUpdateDescriptorSetWithTemplate-pData-01685", + "text": " pData must be a valid pointer to a memory containing one or more valid instances of VkDescriptorImageInfo, VkDescriptorBufferInfo, or VkBufferView in a layout defined by descriptorUpdateTemplate when it was created with vkCreateDescriptorUpdateTemplate" + } + ] + }, + "vkCmdBindDescriptorSets": { + "core": [ + { + "vuid": "VUID-vkCmdBindDescriptorSets-pDescriptorSets-00358", + "text": " Each element of pDescriptorSets must have been allocated with a VkDescriptorSetLayout that matches (is the same as, or identically defined as) the VkDescriptorSetLayout at set n in layout, where n is the sum of firstSet and the index into pDescriptorSets" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-dynamicOffsetCount-00359", + "text": " dynamicOffsetCount must be equal to the total number of dynamic descriptors in pDescriptorSets" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-firstSet-00360", + "text": " The sum of firstSet and descriptorSetCount must be less than or equal to VkPipelineLayoutCreateInfo::setLayoutCount provided when layout was created" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-pipelineBindPoint-00361", + "text": " pipelineBindPoint must be supported by the commandBuffer’s parent VkCommandPool’s queue family" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-pDynamicOffsets-01971", + "text": " Each element of pDynamicOffsets which corresponds to a descriptor binding with type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC must be a multiple of VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-pDynamicOffsets-01972", + "text": " Each element of pDynamicOffsets which corresponds to a descriptor binding with type VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must be a multiple of VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-pDescriptorSets-01979", + "text": " For each dynamic uniform or storage buffer binding in pDescriptorSets, the sum of the effective offset, as defined above, and the range of the binding must be less than or equal to the size of the buffer" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-pipelineBindPoint-parameter", + "text": " pipelineBindPoint must be a valid VkPipelineBindPoint value" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-layout-parameter", + "text": " layout must be a valid VkPipelineLayout handle" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-pDescriptorSets-parameter", + "text": " pDescriptorSets must be a valid pointer to an array of descriptorSetCount valid VkDescriptorSet handles" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-pDynamicOffsets-parameter", + "text": " If dynamicOffsetCount is not 0, pDynamicOffsets must be a valid pointer to an array of dynamicOffsetCount uint32_t values" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-descriptorSetCount-arraylength", + "text": " descriptorSetCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdBindDescriptorSets-commonparent", + "text": " Each of commandBuffer, layout, and the elements of pDescriptorSets must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VALVE_mutable_descriptor_type)": [ + { + "vuid": "VUID-vkCmdBindDescriptorSets-pDescriptorSets-04616", + "text": " Each element of pDescriptorSets must not have been allocated from a VkDescriptorPool with the VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE flag set" + } + ] + }, + "vkCmdPushDescriptorSetKHR": { + "(VK_KHR_push_descriptor)": [ + { + "vuid": "VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-00363", + "text": " pipelineBindPoint must be supported by the commandBuffer’s parent VkCommandPool’s queue family" + }, + { + "vuid": "VUID-vkCmdPushDescriptorSetKHR-set-00364", + "text": " set must be less than VkPipelineLayoutCreateInfo::setLayoutCount provided when layout was created" + }, + { + "vuid": "VUID-vkCmdPushDescriptorSetKHR-set-00365", + "text": " set must be the unique set number in the pipeline layout that uses a descriptor set layout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR" + } + ] + }, + "vkCmdPushDescriptorSetWithTemplateKHR": { + "(VK_KHR_push_descriptor)+(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [ + { + "vuid": "VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-00366", + "text": " The pipelineBindPoint specified during the creation of the descriptor update template must be supported by the commandBuffer’s parent VkCommandPool’s queue family" + }, + { + "vuid": "VUID-vkCmdPushDescriptorSetWithTemplateKHR-pData-01686", + "text": " pData must be a valid pointer to a memory containing one or more valid instances of VkDescriptorImageInfo, VkDescriptorBufferInfo, or VkBufferView in a layout defined by descriptorUpdateTemplate when it was created with vkCreateDescriptorUpdateTemplate" + } + ] + }, + "vkCmdPushConstants": { + "core": [ + { + "vuid": "VUID-vkCmdPushConstants-offset-01795", + "text": " For each byte in the range specified by offset and size and for each shader stage in stageFlags, there must be a push constant range in layout that includes that byte and that stage" + }, + { + "vuid": "VUID-vkCmdPushConstants-offset-01796", + "text": " For each byte in the range specified by offset and size and for each push constant range that overlaps that byte, stageFlags must include all stages in that push constant range’s VkPushConstantRange::stageFlags" + }, + { + "vuid": "VUID-vkCmdPushConstants-offset-00368", + "text": " offset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdPushConstants-size-00369", + "text": " size must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdPushConstants-offset-00370", + "text": " offset must be less than VkPhysicalDeviceLimits::maxPushConstantsSize" + }, + { + "vuid": "VUID-vkCmdPushConstants-size-00371", + "text": " size must be less than or equal to VkPhysicalDeviceLimits::maxPushConstantsSize minus offset" + }, + { + "vuid": "VUID-vkCmdPushConstants-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdPushConstants-layout-parameter", + "text": " layout must be a valid VkPipelineLayout handle" + }, + { + "vuid": "VUID-vkCmdPushConstants-stageFlags-parameter", + "text": " stageFlags must be a valid combination of VkShaderStageFlagBits values" + }, + { + "vuid": "VUID-vkCmdPushConstants-stageFlags-requiredbitmask", + "text": " stageFlags must not be 0" + }, + { + "vuid": "VUID-vkCmdPushConstants-pValues-parameter", + "text": " pValues must be a valid pointer to an array of size bytes" + }, + { + "vuid": "VUID-vkCmdPushConstants-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdPushConstants-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdPushConstants-size-arraylength", + "text": " size must be greater than 0" + }, + { + "vuid": "VUID-vkCmdPushConstants-commonparent", + "text": " Both of commandBuffer, and layout must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "vkGetBufferDeviceAddress": { + "(VK_VERSION_1_2,VK_EXT_buffer_device_address,VK_KHR_buffer_device_address)+(VK_EXT_buffer_device_address)": [ + { + "vuid": "VUID-vkGetBufferDeviceAddress-bufferDeviceAddress-03324", + "text": " The bufferDeviceAddress or VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::bufferDeviceAddress feature must be enabled" + }, + { + "vuid": "VUID-vkGetBufferDeviceAddress-device-03325", + "text": " If device was created with multiple physical devices, then the bufferDeviceAddressMultiDevice or VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::bufferDeviceAddressMultiDevice feature must be enabled" + } + ], + "(VK_VERSION_1_2,VK_EXT_buffer_device_address,VK_KHR_buffer_device_address)+!(VK_EXT_buffer_device_address)": [ + { + "vuid": "VUID-vkGetBufferDeviceAddress-None-06542", + "text": " The bufferDeviceAddress feature must be enabled" + }, + { + "vuid": "VUID-vkGetBufferDeviceAddress-device-06543", + "text": " If device was created with multiple physical devices, then the bufferDeviceAddressMultiDevice feature must be enabled" + } + ], + "(VK_VERSION_1_2,VK_EXT_buffer_device_address,VK_KHR_buffer_device_address)": [ + { + "vuid": "VUID-vkGetBufferDeviceAddress-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetBufferDeviceAddress-pInfo-parameter", + "text": " pInfo must be a valid pointer to a valid VkBufferDeviceAddressInfo structure" + } + ] + }, + "VkBufferDeviceAddressInfo": { + "(VK_VERSION_1_2,VK_EXT_buffer_device_address,VK_KHR_buffer_device_address)": [ + { + "vuid": "VUID-VkBufferDeviceAddressInfo-buffer-02600", + "text": " If buffer is non-sparse and was not created with the VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT flag, then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkBufferDeviceAddressInfo-buffer-02601", + "text": " buffer must have been created with VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT" + }, + { + "vuid": "VUID-VkBufferDeviceAddressInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO" + }, + { + "vuid": "VUID-VkBufferDeviceAddressInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkBufferDeviceAddressInfo-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + } + ] + }, + "vkGetBufferOpaqueCaptureAddress": { + "(VK_VERSION_1_2,VK_KHR_buffer_device_address)": [ + { + "vuid": "VUID-vkGetBufferOpaqueCaptureAddress-None-03326", + "text": " The bufferDeviceAddress feature must be enabled" + }, + { + "vuid": "VUID-vkGetBufferOpaqueCaptureAddress-device-03327", + "text": " If device was created with multiple physical devices, then the bufferDeviceAddressMultiDevice feature must be enabled" + }, + { + "vuid": "VUID-vkGetBufferOpaqueCaptureAddress-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetBufferOpaqueCaptureAddress-pInfo-parameter", + "text": " pInfo must be a valid pointer to a valid VkBufferDeviceAddressInfo structure" + } + ] + }, + "BaryCoordNV": { + "(VK_NV_fragment_shader_barycentric)": [ + { + "vuid": "VUID-BaryCoordNV-BaryCoordNV-04154", + "text": " The BaryCoordNV decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-BaryCoordNV-BaryCoordNV-04155", + "text": " The variable decorated with BaryCoordNV must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-BaryCoordNV-BaryCoordNV-04156", + "text": " The variable decorated with BaryCoordNV must be declared as a three-component vector of 32-bit floating-point values" + } + ] + }, + "BaryCoordNoPerspAMD": { + "(VK_AMD_shader_explicit_vertex_parameter)": [ + { + "vuid": "VUID-BaryCoordNoPerspAMD-BaryCoordNoPerspAMD-04157", + "text": " The BaryCoordNoPerspAMD decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-BaryCoordNoPerspAMD-BaryCoordNoPerspAMD-04158", + "text": " The variable decorated with BaryCoordNoPerspAMD must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-BaryCoordNoPerspAMD-BaryCoordNoPerspAMD-04159", + "text": " The variable decorated with BaryCoordNoPerspAMD must be declared as a two-component vector of 32-bit floating-point values" + } + ] + }, + "BaryCoordNoPerspNV": { + "(VK_NV_fragment_shader_barycentric)": [ + { + "vuid": "VUID-BaryCoordNoPerspNV-BaryCoordNoPerspNV-04160", + "text": " The BaryCoordNoPerspNV decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-BaryCoordNoPerspNV-BaryCoordNoPerspNV-04161", + "text": " The variable decorated with BaryCoordNoPerspNV must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-BaryCoordNoPerspNV-BaryCoordNoPerspNV-04162", + "text": " The variable decorated with BaryCoordNoPerspNV must be declared as a three-component vector of 32-bit floating-point values" + } + ] + }, + "BaryCoordNoPerspCentroidAMD": { + "(VK_AMD_shader_explicit_vertex_parameter)": [ + { + "vuid": "VUID-BaryCoordNoPerspCentroidAMD-BaryCoordNoPerspCentroidAMD-04163", + "text": " The BaryCoordNoPerspCentroidAMD decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-BaryCoordNoPerspCentroidAMD-BaryCoordNoPerspCentroidAMD-04164", + "text": " The variable decorated with BaryCoordNoPerspCentroidAMD must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-BaryCoordNoPerspCentroidAMD-BaryCoordNoPerspCentroidAMD-04165", + "text": " The variable decorated with BaryCoordNoPerspCentroidAMD must be declared as a three-component vector of 32-bit floating-point values" + } + ] + }, + "BaryCoordNoPerspSampleAMD": { + "(VK_AMD_shader_explicit_vertex_parameter)": [ + { + "vuid": "VUID-BaryCoordNoPerspSampleAMD-BaryCoordNoPerspSampleAMD-04166", + "text": " The BaryCoordNoPerspSampleAMD decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-BaryCoordNoPerspSampleAMD-BaryCoordNoPerspSampleAMD-04167", + "text": " The variable decorated with BaryCoordNoPerspSampleAMD must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-BaryCoordNoPerspSampleAMD-BaryCoordNoPerspSampleAMD-04168", + "text": " The variable decorated with BaryCoordNoPerspSampleAMD must be declared as a two-component vector of 32-bit floating-point values" + } + ] + }, + "BaryCoordPullModelAMD": { + "(VK_AMD_shader_explicit_vertex_parameter)": [ + { + "vuid": "VUID-BaryCoordPullModelAMD-BaryCoordPullModelAMD-04169", + "text": " The BaryCoordPullModelAMD decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-BaryCoordPullModelAMD-BaryCoordPullModelAMD-04170", + "text": " The variable decorated with BaryCoordPullModelAMD must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-BaryCoordPullModelAMD-BaryCoordPullModelAMD-04171", + "text": " The variable decorated with BaryCoordPullModelAMD must be declared as a three-component vector of 32-bit floating-point values" + } + ] + }, + "BaryCoordSmoothAMD": { + "(VK_AMD_shader_explicit_vertex_parameter)": [ + { + "vuid": "VUID-BaryCoordSmoothAMD-BaryCoordSmoothAMD-04172", + "text": " The BaryCoordSmoothAMD decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-BaryCoordSmoothAMD-BaryCoordSmoothAMD-04173", + "text": " The variable decorated with BaryCoordSmoothAMD must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-BaryCoordSmoothAMD-BaryCoordSmoothAMD-04174", + "text": " The variable decorated with BaryCoordSmoothAMD must be declared as a two-component vector of 32-bit floating-point values" + } + ] + }, + "BaryCoordSmoothCentroidAMD": { + "(VK_AMD_shader_explicit_vertex_parameter)": [ + { + "vuid": "VUID-BaryCoordSmoothCentroidAMD-BaryCoordSmoothCentroidAMD-04175", + "text": " The BaryCoordSmoothCentroidAMD decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-BaryCoordSmoothCentroidAMD-BaryCoordSmoothCentroidAMD-04176", + "text": " The variable decorated with BaryCoordSmoothCentroidAMD must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-BaryCoordSmoothCentroidAMD-BaryCoordSmoothCentroidAMD-04177", + "text": " The variable decorated with BaryCoordSmoothCentroidAMD must be declared as a two-component vector of 32-bit floating-point values" + } + ] + }, + "BaryCoordSmoothSampleAMD": { + "(VK_AMD_shader_explicit_vertex_parameter)": [ + { + "vuid": "VUID-BaryCoordSmoothSampleAMD-BaryCoordSmoothSampleAMD-04178", + "text": " The BaryCoordSmoothSampleAMD decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-BaryCoordSmoothSampleAMD-BaryCoordSmoothSampleAMD-04179", + "text": " The variable decorated with BaryCoordSmoothSampleAMD must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-BaryCoordSmoothSampleAMD-BaryCoordSmoothSampleAMD-04180", + "text": " The variable decorated with BaryCoordSmoothSampleAMD must be declared as a two-component vector of 32-bit floating-point values" + } + ] + }, + "BaseInstance": { + "(VK_VERSION_1_1,VK_KHR_shader_draw_parameters)": [ + { + "vuid": "VUID-BaseInstance-BaseInstance-04181", + "text": " The BaseInstance decoration must be used only within the Vertex {ExecutionModel}" + }, + { + "vuid": "VUID-BaseInstance-BaseInstance-04182", + "text": " The variable decorated with BaseInstance must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-BaseInstance-BaseInstance-04183", + "text": " The variable decorated with BaseInstance must be declared as a scalar 32-bit integer value" + } + ] + }, + "BaseVertex": { + "(VK_VERSION_1_1,VK_KHR_shader_draw_parameters)": [ + { + "vuid": "VUID-BaseVertex-BaseVertex-04184", + "text": " The BaseVertex decoration must be used only within the Vertex {ExecutionModel}" + }, + { + "vuid": "VUID-BaseVertex-BaseVertex-04185", + "text": " The variable decorated with BaseVertex must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-BaseVertex-BaseVertex-04186", + "text": " The variable decorated with BaseVertex must be declared as a scalar 32-bit integer value" + } + ] + }, + "ClipDistance": { + "core": [ + { + "vuid": "VUID-ClipDistance-ClipDistance-04187", + "text": " The ClipDistance decoration must be used only within the MeshNV, Vertex, Fragment, TessellationControl, TessellationEvaluation, or Geometry {ExecutionModel}" + }, + { + "vuid": "VUID-ClipDistance-ClipDistance-04188", + "text": " The variable decorated with ClipDistance within the MeshNV or Vertex {ExecutionModel} must be declared using the Output {StorageClass}" + }, + { + "vuid": "VUID-ClipDistance-ClipDistance-04189", + "text": " The variable decorated with ClipDistance within the Fragment {ExecutionModel} must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-ClipDistance-ClipDistance-04190", + "text": " The variable decorated with ClipDistance within the TessellationControl, TessellationEvaluation, or Geometry {ExecutionModel} must not be declared in a {StorageClass} other than Input or Output" + }, + { + "vuid": "VUID-ClipDistance-ClipDistance-04191", + "text": " The variable decorated with ClipDistance must be declared as an array of 32-bit floating-point values" + } + ] + }, + "ClipDistancePerViewNV": { + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-ClipDistancePerViewNV-ClipDistancePerViewNV-04192", + "text": " The ClipDistancePerViewNV decoration must be used only within the MeshNV {ExecutionModel}" + }, + { + "vuid": "VUID-ClipDistancePerViewNV-ClipDistancePerViewNV-04193", + "text": " The variable decorated with ClipDistancePerViewNV must be declared using the Output {StorageClass}" + }, + { + "vuid": "VUID-ClipDistancePerViewNV-ClipDistancePerViewNV-04194", + "text": " The variable decorated with ClipDistancePerViewNV must also be decorated with the PerViewNV decoration" + }, + { + "vuid": "VUID-ClipDistancePerViewNV-ClipDistancePerViewNV-04195", + "text": " The variable decorated with ClipDistancePerViewNV must be declared as a two-dimensional array of 32-bit floating-point values" + } + ] + }, + "CullDistance": { + "core": [ + { + "vuid": "VUID-CullDistance-CullDistance-04196", + "text": " The CullDistance decoration must be used only within the MeshNV, Vertex, Fragment, TessellationControl, TessellationEvaluation, or Geometry {ExecutionModel}" + }, + { + "vuid": "VUID-CullDistance-CullDistance-04197", + "text": " The variable decorated with CullDistance within the MeshNV or Vertex {ExecutionModel} must be declared using the Output {StorageClass}" + }, + { + "vuid": "VUID-CullDistance-CullDistance-04198", + "text": " The variable decorated with CullDistance within the Fragment {ExecutionModel} must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-CullDistance-CullDistance-04199", + "text": " The variable decorated with CullDistance within the TessellationControl, TessellationEvaluation, or Geometry {ExecutionModel} must not be declared using a {StorageClass} other than Input or Output" + }, + { + "vuid": "VUID-CullDistance-CullDistance-04200", + "text": " The variable decorated with CullDistance must be declared as an array of 32-bit floating-point values" + } + ] + }, + "CullDistancePerViewNV": { + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-CullDistancePerViewNV-CullDistancePerViewNV-04201", + "text": " The CullDistancePerViewNV decoration must be used only within the MeshNV {ExecutionModel}" + }, + { + "vuid": "VUID-CullDistancePerViewNV-CullDistancePerViewNV-04202", + "text": " The variable decorated with CullDistancePerViewNV must be declared using the Output {StorageClass}" + }, + { + "vuid": "VUID-CullDistancePerViewNV-CullDistancePerViewNV-04203", + "text": " The variable decorated with CullDistancePerViewNV must also be decorated with the PerViewNV decoration" + }, + { + "vuid": "VUID-CullDistancePerViewNV-CullDistancePerViewNV-04204", + "text": " The variable decorated with CullDistancePerViewNV must be declared as a two-dimensional array of 32-bit floating-point values" + } + ] + }, + "CurrentRayTimeNV": { + "(VK_NV_ray_tracing_motion_blur)": [ + { + "vuid": "VUID-CurrentRayTimeNV-CurrentRayTimeNV-04942", + "text": " The CurrentRayTimeNV decoration must be used only within the IntersectionKHR, AnyHitKHR, ClosestHitKHR, or MissKHR {ExecutionModel}" + }, + { + "vuid": "VUID-CurrentRayTimeNV-CurrentRayTimeNV-04943", + "text": " The variable decorated with CurrentRayTimeNV must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-CurrentRayTimeNV-CurrentRayTimeNV-04944", + "text": " The variable decorated with CurrentRayTimeNV must be declared as a scalar 32-bit floating-point value" + } + ] + }, + "DeviceIndex": { + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-DeviceIndex-DeviceIndex-04205", + "text": " The variable decorated with DeviceIndex must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-DeviceIndex-DeviceIndex-04206", + "text": " The variable decorated with DeviceIndex must be declared as a scalar 32-bit integer value" + } + ] + }, + "DrawIndex": { + "(VK_VERSION_1_1,VK_KHR_shader_draw_parameters)": [ + { + "vuid": "VUID-DrawIndex-DrawIndex-04207", + "text": " The DrawIndex decoration must be used only within the Vertex, MeshNV, or TaskNV {ExecutionModel}" + }, + { + "vuid": "VUID-DrawIndex-DrawIndex-04208", + "text": " The variable decorated with DrawIndex must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-DrawIndex-DrawIndex-04209", + "text": " The variable decorated with DrawIndex must be declared as a scalar 32-bit integer value" + } + ] + }, + "FragCoord": { + "core": [ + { + "vuid": "VUID-FragCoord-FragCoord-04210", + "text": " The FragCoord decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-FragCoord-FragCoord-04211", + "text": " The variable decorated with FragCoord must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-FragCoord-FragCoord-04212", + "text": " The variable decorated with FragCoord must be declared as a four-component vector of 32-bit floating-point values" + } + ] + }, + "FragDepth": { + "core": [ + { + "vuid": "VUID-FragDepth-FragDepth-04213", + "text": " The FragDepth decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-FragDepth-FragDepth-04214", + "text": " The variable decorated with FragDepth must be declared using the Output {StorageClass}" + }, + { + "vuid": "VUID-FragDepth-FragDepth-04215", + "text": " The variable decorated with FragDepth must be declared as a scalar 32-bit floating-point value" + }, + { + "vuid": "VUID-FragDepth-FragDepth-04216", + "text": " If the shader dynamically writes to the variable decorated with FragDepth, the DepthReplacing {ExecutionMode} must be declared" + } + ] + }, + "FragInvocationCountEXT": { + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-FragInvocationCountEXT-FragInvocationCountEXT-04217", + "text": " The FragInvocationCountEXT decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-FragInvocationCountEXT-FragInvocationCountEXT-04218", + "text": " The variable decorated with FragInvocationCountEXT must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-FragInvocationCountEXT-FragInvocationCountEXT-04219", + "text": " The variable decorated with FragInvocationCountEXT must be declared as a scalar 32-bit integer value" + } + ] + }, + "FragSizeEXT": { + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-FragSizeEXT-FragSizeEXT-04220", + "text": " The FragSizeEXT decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-FragSizeEXT-FragSizeEXT-04221", + "text": " The variable decorated with FragSizeEXT must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-FragSizeEXT-FragSizeEXT-04222", + "text": " The variable decorated with FragSizeEXT must be declared as a two-component vector of 32-bit integer values" + } + ] + }, + "FragStencilRefEXT": { + "(VK_EXT_shader_stencil_export)": [ + { + "vuid": "VUID-FragStencilRefEXT-FragStencilRefEXT-04223", + "text": " The FragStencilRefEXT decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-FragStencilRefEXT-FragStencilRefEXT-04224", + "text": " The variable decorated with FragStencilRefEXT must be declared using the Output {StorageClass}" + }, + { + "vuid": "VUID-FragStencilRefEXT-FragStencilRefEXT-04225", + "text": " The variable decorated with FragStencilRefEXT must be declared as a scalar integer value" + } + ] + }, + "FragmentSizeNV": { + "(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-FragmentSizeNV-FragmentSizeNV-04226", + "text": " The FragmentSizeNV decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-FragmentSizeNV-FragmentSizeNV-04227", + "text": " The variable decorated with FragmentSizeNV must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-FragmentSizeNV-FragmentSizeNV-04228", + "text": " The variable decorated with FragmentSizeNV must be declared as a two-component vector of 32-bit integer values" + } + ] + }, + "FrontFacing": { + "core": [ + { + "vuid": "VUID-FrontFacing-FrontFacing-04229", + "text": " The FrontFacing decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-FrontFacing-FrontFacing-04230", + "text": " The variable decorated with FrontFacing must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-FrontFacing-FrontFacing-04231", + "text": " The variable decorated with FrontFacing must be declared as a boolean value" + } + ] + }, + "FullyCoveredEXT": { + "(VK_EXT_conservative_rasterization)": [ + { + "vuid": "VUID-FullyCoveredEXT-FullyCoveredEXT-04232", + "text": " The FullyCoveredEXT decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-FullyCoveredEXT-FullyCoveredEXT-04233", + "text": " The variable decorated with FullyCoveredEXT must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-FullyCoveredEXT-FullyCoveredEXT-04234", + "text": " The variable decorated with FullyCoveredEXT must be declared as a boolean value" + } + ], + "(VK_EXT_conservative_rasterization)+(VK_EXT_post_depth_coverage)": [ + { + "vuid": "VUID-FullyCoveredEXT-conservativeRasterizationPostDepthCoverage-04235", + "text": " If VkPhysicalDeviceConservativeRasterizationPropertiesEXT::conservativeRasterizationPostDepthCoverage is not supported the PostDepthCoverage {ExecutionMode} must not be declared, when a variable with the FullyCoveredEXT decoration is declared" + } + ] + }, + "GlobalInvocationId": { + "core": [ + { + "vuid": "VUID-GlobalInvocationId-GlobalInvocationId-04236", + "text": " The GlobalInvocationId decoration must be used only within the GLCompute, MeshNV, or TaskNV {ExecutionModel}" + }, + { + "vuid": "VUID-GlobalInvocationId-GlobalInvocationId-04237", + "text": " The variable decorated with GlobalInvocationId must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-GlobalInvocationId-GlobalInvocationId-04238", + "text": " The variable decorated with GlobalInvocationId must be declared as a three-component vector of 32-bit integer values" + } + ] + }, + "HelperInvocation": { + "core": [ + { + "vuid": "VUID-HelperInvocation-HelperInvocation-04239", + "text": " The HelperInvocation decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-HelperInvocation-HelperInvocation-04240", + "text": " The variable decorated with HelperInvocation must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-HelperInvocation-HelperInvocation-04241", + "text": " The variable decorated with HelperInvocation must be declared as a boolean value" + } + ] + }, + "HitKindKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-HitKindKHR-HitKindKHR-04242", + "text": " The HitKindKHR decoration must be used only within the AnyHitKHR or ClosestHitKHR {ExecutionModel}" + }, + { + "vuid": "VUID-HitKindKHR-HitKindKHR-04243", + "text": " The variable decorated with HitKindKHR must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-HitKindKHR-HitKindKHR-04244", + "text": " The variable decorated with HitKindKHR must be declared as a scalar 32-bit integer value" + } + ] + }, + "HitTNV": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-HitTNV-HitTNV-04245", + "text": " The HitTNV decoration must be used only within the AnyHitNV or ClosestHitNV {ExecutionModel}" + }, + { + "vuid": "VUID-HitTNV-HitTNV-04246", + "text": " The variable decorated with HitTNV must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-HitTNV-HitTNV-04247", + "text": " The variable decorated with HitTNV must be declared as a scalar 32-bit floating-point value" + } + ] + }, + "IncomingRayFlagsKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04248", + "text": " The IncomingRayFlagsKHR decoration must be used only within the IntersectionKHR, AnyHitKHR, ClosestHitKHR, or MissKHR {ExecutionModel}" + }, + { + "vuid": "VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04249", + "text": " The variable decorated with IncomingRayFlagsKHR must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04250", + "text": " The variable decorated with IncomingRayFlagsKHR must be declared as a scalar 32-bit integer value" + } + ] + }, + "InstanceCustomIndexKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-InstanceCustomIndexKHR-InstanceCustomIndexKHR-04251", + "text": " The InstanceCustomIndexKHR decoration must be used only within the IntersectionKHR, AnyHitKHR, or ClosestHitKHR {ExecutionModel}" + }, + { + "vuid": "VUID-InstanceCustomIndexKHR-InstanceCustomIndexKHR-04252", + "text": " The variable decorated with InstanceCustomIndexKHR must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-InstanceCustomIndexKHR-InstanceCustomIndexKHR-04253", + "text": " The variable decorated with InstanceCustomIndexKHR must be declared as a scalar 32-bit integer value" + } + ] + }, + "InstanceId": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-InstanceId-InstanceId-04254", + "text": " The InstanceId decoration must be used only within the IntersectionKHR, AnyHitKHR, or ClosestHitKHR {ExecutionModel}" + }, + { + "vuid": "VUID-InstanceId-InstanceId-04255", + "text": " The variable decorated with InstanceId must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-InstanceId-InstanceId-04256", + "text": " The variable decorated with InstanceId must be declared as a scalar 32-bit integer value" + } + ] + }, + "InvocationId": { + "core": [ + { + "vuid": "VUID-InvocationId-InvocationId-04257", + "text": " The InvocationId decoration must be used only within the TessellationControl or Geometry {ExecutionModel}" + }, + { + "vuid": "VUID-InvocationId-InvocationId-04258", + "text": " The variable decorated with InvocationId must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-InvocationId-InvocationId-04259", + "text": " The variable decorated with InvocationId must be declared as a scalar 32-bit integer value" + } + ] + }, + "InvocationsPerPixelNV": { + "(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-InvocationsPerPixelNV-InvocationsPerPixelNV-04260", + "text": " The InvocationsPerPixelNV decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-InvocationsPerPixelNV-InvocationsPerPixelNV-04261", + "text": " The variable decorated with InvocationsPerPixelNV must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-InvocationsPerPixelNV-InvocationsPerPixelNV-04262", + "text": " The variable decorated with InvocationsPerPixelNV must be declared as a scalar 32-bit integer value" + } + ] + }, + "InstanceIndex": { + "core": [ + { + "vuid": "VUID-InstanceIndex-InstanceIndex-04263", + "text": " The InstanceIndex decoration must be used only within the Vertex {ExecutionModel}" + }, + { + "vuid": "VUID-InstanceIndex-InstanceIndex-04264", + "text": " The variable decorated with InstanceIndex must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-InstanceIndex-InstanceIndex-04265", + "text": " The variable decorated with InstanceIndex must be declared as a scalar 32-bit integer value" + } + ] + }, + "LaunchIdKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-LaunchIdKHR-LaunchIdKHR-04266", + "text": " The LaunchIdKHR decoration must be used only within the RayGenerationKHR, IntersectionKHR, AnyHitKHR, ClosestHitKHR, MissKHR, or CallableKHR {ExecutionModel}" + }, + { + "vuid": "VUID-LaunchIdKHR-LaunchIdKHR-04267", + "text": " The variable decorated with LaunchIdKHR must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-LaunchIdKHR-LaunchIdKHR-04268", + "text": " The variable decorated with LaunchIdKHR must be declared as a three-component vector of 32-bit integer values" + } + ] + }, + "LaunchSizeKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-LaunchSizeKHR-LaunchSizeKHR-04269", + "text": " The LaunchSizeKHR decoration must be used only within the RayGenerationKHR, IntersectionKHR, AnyHitKHR, ClosestHitKHR, MissKHR, or CallableKHR {ExecutionModel}" + }, + { + "vuid": "VUID-LaunchSizeKHR-LaunchSizeKHR-04270", + "text": " The variable decorated with LaunchSizeKHR must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-LaunchSizeKHR-LaunchSizeKHR-04271", + "text": " The variable decorated with LaunchSizeKHR must be declared as a three-component vector of 32-bit integer values" + } + ] + }, + "Layer": { + "core": [ + { + "vuid": "VUID-Layer-Layer-04272", + "text": " The Layer decoration must be used only within the MeshNV, Vertex, TessellationEvaluation, Geometry, or Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-Layer-Layer-04274", + "text": " The variable decorated with Layer within the MeshNV, Vertex, TessellationEvaluation, or Geometry {ExecutionModel} must be declared using the Output {StorageClass}" + }, + { + "vuid": "VUID-Layer-Layer-04275", + "text": " The variable decorated with Layer within the Fragment {ExecutionModel} must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-Layer-Layer-04276", + "text": " The variable decorated with Layer must be declared as a scalar 32-bit integer value" + } + ], + "(VK_VERSION_1_2)": [ + { + "vuid": "VUID-Layer-Layer-04273", + "text": " If the shaderOutputLayer feature is not enabled then the Layer decoration must be used only within the Geometry or Fragment {ExecutionModel}" + } + ] + }, + "LayerPerViewNV": { + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-LayerPerViewNV-LayerPerViewNV-04277", + "text": " The LayerPerViewNV decoration must be used only within the MeshNV {ExecutionModel}" + }, + { + "vuid": "VUID-LayerPerViewNV-LayerPerViewNV-04278", + "text": " The variable decorated with LayerPerViewNV must be declared using the Output {StorageClass}" + }, + { + "vuid": "VUID-LayerPerViewNV-LayerPerViewNV-04279", + "text": " The variable decorated with LayerPerViewNV must also be decorated with the PerViewNV decoration" + }, + { + "vuid": "VUID-LayerPerViewNV-LayerPerViewNV-04280", + "text": " The variable decorated with LayerPerViewNV must be declared as an array of scalar 32-bit integer values" + } + ] + }, + "LocalInvocationId": { + "core": [ + { + "vuid": "VUID-LocalInvocationId-LocalInvocationId-04281", + "text": " The LocalInvocationId decoration must be used only within the GLCompute, MeshNV, or TaskNV {ExecutionModel}" + }, + { + "vuid": "VUID-LocalInvocationId-LocalInvocationId-04282", + "text": " The variable decorated with LocalInvocationId must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-LocalInvocationId-LocalInvocationId-04283", + "text": " The variable decorated with LocalInvocationId must be declared as a three-component vector of 32-bit integer values" + } + ] + }, + "LocalInvocationIndex": { + "core": [ + { + "vuid": "VUID-LocalInvocationIndex-LocalInvocationIndex-04284", + "text": " The LocalInvocationIndex decoration must be used only within the GLCompute, MeshNV, or TaskNV {ExecutionModel}" + }, + { + "vuid": "VUID-LocalInvocationIndex-LocalInvocationIndex-04285", + "text": " The variable decorated with LocalInvocationIndex must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-LocalInvocationIndex-LocalInvocationIndex-04286", + "text": " The variable decorated with LocalInvocationIndex must be declared as a scalar 32-bit integer value" + } + ] + }, + "MeshViewCountNV": { + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-MeshViewCountNV-MeshViewCountNV-04287", + "text": " The MeshViewCountNV decoration must be used only within the MeshNV or TaskNV {ExecutionModel}" + }, + { + "vuid": "VUID-MeshViewCountNV-MeshViewCountNV-04288", + "text": " The variable decorated with MeshViewCountNV must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-MeshViewCountNV-MeshViewCountNV-04289", + "text": " The variable decorated with MeshViewCountNV must be declared as a scalar 32-bit integer value" + } + ] + }, + "MeshViewIndicesNV": { + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-MeshViewIndicesNV-MeshViewIndicesNV-04290", + "text": " The MeshViewIndicesNV decoration must be used only within the MeshNV or TaskNV {ExecutionModel}" + }, + { + "vuid": "VUID-MeshViewIndicesNV-MeshViewIndicesNV-04291", + "text": " The variable decorated with MeshViewIndicesNV must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-MeshViewIndicesNV-MeshViewIndicesNV-04292", + "text": " The variable decorated with MeshViewIndicesNV must be declared as an array of scalar 32-bit integer values" + } + ] + }, + "NumSubgroups": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-NumSubgroups-NumSubgroups-04293", + "text": " The NumSubgroups decoration must be used only within the GLCompute, MeshNV, or TaskNV {ExecutionModel}" + }, + { + "vuid": "VUID-NumSubgroups-NumSubgroups-04294", + "text": " The variable decorated with NumSubgroups must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-NumSubgroups-NumSubgroups-04295", + "text": " The variable decorated with NumSubgroups must be declared as a scalar 32-bit integer value" + } + ] + }, + "NumWorkgroups": { + "core": [ + { + "vuid": "VUID-NumWorkgroups-NumWorkgroups-04296", + "text": " The NumWorkgroups decoration must be used only within the GLCompute {ExecutionModel}" + }, + { + "vuid": "VUID-NumWorkgroups-NumWorkgroups-04297", + "text": " The variable decorated with NumWorkgroups must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-NumWorkgroups-NumWorkgroups-04298", + "text": " The variable decorated with NumWorkgroups must be declared as a three-component vector of 32-bit integer values" + } + ] + }, + "ObjectRayDirectionKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-ObjectRayDirectionKHR-ObjectRayDirectionKHR-04299", + "text": " The ObjectRayDirectionKHR decoration must be used only within the IntersectionKHR, AnyHitKHR, or ClosestHitKHR {ExecutionModel}" + }, + { + "vuid": "VUID-ObjectRayDirectionKHR-ObjectRayDirectionKHR-04300", + "text": " The variable decorated with ObjectRayDirectionKHR must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-ObjectRayDirectionKHR-ObjectRayDirectionKHR-04301", + "text": " The variable decorated with ObjectRayDirectionKHR must be declared as a three-component vector of 32-bit floating-point values" + } + ] + }, + "ObjectRayOriginKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-ObjectRayOriginKHR-ObjectRayOriginKHR-04302", + "text": " The ObjectRayOriginKHR decoration must be used only within the IntersectionKHR, AnyHitKHR, or ClosestHitKHR {ExecutionModel}" + }, + { + "vuid": "VUID-ObjectRayOriginKHR-ObjectRayOriginKHR-04303", + "text": " The variable decorated with ObjectRayOriginKHR must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-ObjectRayOriginKHR-ObjectRayOriginKHR-04304", + "text": " The variable decorated with ObjectRayOriginKHR must be declared as a three-component vector of 32-bit floating-point values" + } + ] + }, + "ObjectToWorldKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-ObjectToWorldKHR-ObjectToWorldKHR-04305", + "text": " The ObjectToWorldKHR decoration must be used only within the IntersectionKHR, AnyHitKHR, or ClosestHitKHR {ExecutionModel}" + }, + { + "vuid": "VUID-ObjectToWorldKHR-ObjectToWorldKHR-04306", + "text": " The variable decorated with ObjectToWorldKHR must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-ObjectToWorldKHR-ObjectToWorldKHR-04307", + "text": " The variable decorated with ObjectToWorldKHR must be declared as a matrix with four columns of three-component vectors of 32-bit floating-point values" + } + ] + }, + "PatchVertices": { + "core": [ + { + "vuid": "VUID-PatchVertices-PatchVertices-04308", + "text": " The PatchVertices decoration must be used only within the TessellationControl or TessellationEvaluation {ExecutionModel}" + }, + { + "vuid": "VUID-PatchVertices-PatchVertices-04309", + "text": " The variable decorated with PatchVertices must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-PatchVertices-PatchVertices-04310", + "text": " The variable decorated with PatchVertices must be declared as a scalar 32-bit integer value" + } + ] + }, + "PointCoord": { + "core": [ + { + "vuid": "VUID-PointCoord-PointCoord-04311", + "text": " The PointCoord decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-PointCoord-PointCoord-04312", + "text": " The variable decorated with PointCoord must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-PointCoord-PointCoord-04313", + "text": " The variable decorated with PointCoord must be declared as a two-component vector of 32-bit floating-point values" + } + ] + }, + "PointSize": { + "core": [ + { + "vuid": "VUID-PointSize-PointSize-04314", + "text": " The PointSize decoration must be used only within the MeshNV, Vertex, TessellationControl, TessellationEvaluation, or Geometry {ExecutionModel}" + }, + { + "vuid": "VUID-PointSize-PointSize-04315", + "text": " The variable decorated with PointSize within the MeshNV or Vertex {ExecutionModel} must be declared using the Output {StorageClass}" + }, + { + "vuid": "VUID-PointSize-PointSize-04316", + "text": " The variable decorated with PointSize within the TessellationControl, TessellationEvaluation, or Geometry {ExecutionModel} must not be declared using a {StorageClass} other than Input or Output" + }, + { + "vuid": "VUID-PointSize-PointSize-04317", + "text": " The variable decorated with PointSize must be declared as a scalar 32-bit floating-point value" + } + ] + }, + "Position": { + "core": [ + { + "vuid": "VUID-Position-Position-04318", + "text": " The Position decoration must be used only within the MeshNV, Vertex, TessellationControl, TessellationEvaluation, or Geometry {ExecutionModel}" + }, + { + "vuid": "VUID-Position-Position-04319", + "text": " The variable decorated with Position within MeshNV or Vertex {ExecutionModel} must be declared using the Output {StorageClass}" + }, + { + "vuid": "VUID-Position-Position-04320", + "text": " The variable decorated with Position within TessellationControl, TessellationEvaluation, or Geometry {ExecutionModel} must not be declared using a {StorageClass} other than Input or Output" + }, + { + "vuid": "VUID-Position-Position-04321", + "text": " The variable decorated with Position must be declared as a four-component vector of 32-bit floating-point values" + } + ] + }, + "PositionPerViewNV": { + "(VK_NVX_multiview_per_view_attributes)": [ + { + "vuid": "VUID-PositionPerViewNV-PositionPerViewNV-04322", + "text": " The PositionPerViewNV decoration must be used only within the MeshNV, Vertex, TessellationControl, TessellationEvaluation, or Geometry {ExecutionModel}" + }, + { + "vuid": "VUID-PositionPerViewNV-PositionPerViewNV-04323", + "text": " The variable decorated with PositionPerViewNV within the Vertex, or MeshNV {ExecutionModel} must be declared using the Output {StorageClass}" + }, + { + "vuid": "VUID-PositionPerViewNV-PositionPerViewNV-04324", + "text": " The variable decorated with PositionPerViewNV within the TessellationControl, TessellationEvaluation, or Geometry {ExecutionModel} must not be declared using a {StorageClass} other than Input or Output" + }, + { + "vuid": "VUID-PositionPerViewNV-PositionPerViewNV-04325", + "text": " The variable decorated with PositionPerViewNV must be declared as an array of four-component vector of 32-bit floating-point values with at least as many elements as the maximum view in the subpass’s view mask plus one" + }, + { + "vuid": "VUID-PositionPerViewNV-PositionPerViewNV-04326", + "text": " The array variable decorated with PositionPerViewNV must only be indexed by a constant or specialization constant" + } + ] + }, + "PrimitiveCountNV": { + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-PrimitiveCountNV-PrimitiveCountNV-04327", + "text": " The PrimitiveCountNV decoration must be used only within the MeshNV {ExecutionModel}" + }, + { + "vuid": "VUID-PrimitiveCountNV-PrimitiveCountNV-04328", + "text": " The variable decorated with PrimitiveCountNV must be declared using the Output {StorageClass}" + }, + { + "vuid": "VUID-PrimitiveCountNV-PrimitiveCountNV-04329", + "text": " The variable decorated with PrimitiveCountNV must be declared as a scalar 32-bit integer value" + } + ] + }, + "PrimitiveId": { + "core": [ + { + "vuid": "VUID-PrimitiveId-PrimitiveId-04330", + "text": " The PrimitiveId decoration must be used only within the MeshNV, IntersectionKHR, AnyHitKHR, ClosestHitKHR, TessellationControl, TessellationEvaluation, Geometry, or Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-PrimitiveId-Fragment-04331", + "text": " If pipeline contains both the Fragment and Geometry {ExecutionModel} and a variable decorated with PrimitiveId is read from Fragment shader, then the Geometry shader must write to the output variables decorated with PrimitiveId in all execution paths" + }, + { + "vuid": "VUID-PrimitiveId-Fragment-04332", + "text": " If pipeline contains both the Fragment and MeshNV {ExecutionModel} and a variable decorated with PrimitiveId is read from Fragment shader, then the MeshNV shader must write to the output variables decorated with PrimitiveId in all execution paths" + }, + { + "vuid": "VUID-PrimitiveId-Fragment-04333", + "text": " If Fragment {ExecutionModel} contains a variable decorated with PrimitiveId, then either the MeshShadingNV, Geometry or Tessellation capability must also be declared" + }, + { + "vuid": "VUID-PrimitiveId-PrimitiveId-04334", + "text": " The variable decorated with PrimitiveId within the TessellationControl, TessellationEvaluation, Fragment, IntersectionKHR, AnyHitKHR, or ClosestHitKHR {ExecutionModel} must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-PrimitiveId-PrimitiveId-04335", + "text": " The variable decorated with PrimitiveId within the Geometry {ExecutionModel} must be declared using the Input or Output {StorageClass}" + }, + { + "vuid": "VUID-PrimitiveId-PrimitiveId-04336", + "text": " The variable decorated with PrimitiveId within the MeshNV {ExecutionModel} must be declared using the Output {StorageClass}" + }, + { + "vuid": "VUID-PrimitiveId-PrimitiveId-04337", + "text": " The variable decorated with PrimitiveId must be declared as a scalar 32-bit integer value" + } + ] + }, + "PrimitiveIndicesNV": { + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-PrimitiveIndicesNV-PrimitiveIndicesNV-04338", + "text": " The PrimitiveIndicesNV decoration must be used only within the MeshNV {ExecutionModel}" + }, + { + "vuid": "VUID-PrimitiveIndicesNV-PrimitiveIndicesNV-04339", + "text": " The variable decorated with PrimitiveIndicesNV must be declared using the Output {StorageClass}" + }, + { + "vuid": "VUID-PrimitiveIndicesNV-PrimitiveIndicesNV-04340", + "text": " The variable decorated with PrimitiveIndicesNV must be declared as an array of scalar 32-bit integer values" + }, + { + "vuid": "VUID-PrimitiveIndicesNV-PrimitiveIndicesNV-04341", + "text": " All index values of the array decorated with PrimitiveIndicesNV must be in the range [0, N-1], where N is the value specified by the OutputVertices {ExecutionMode}" + }, + { + "vuid": "VUID-PrimitiveIndicesNV-OutputPoints-04342", + "text": " If the {ExecutionMode} is OutputPoints, then the array decorated with PrimitiveIndicesNV must be the size of the value specified by OutputPrimitivesNV" + }, + { + "vuid": "VUID-PrimitiveIndicesNV-OutputLinesNV-04343", + "text": " If the {ExecutionMode} is OutputLinesNV, then the array decorated with PrimitiveIndicesNV must be the size of two times the value specified by OutputPrimitivesNV" + }, + { + "vuid": "VUID-PrimitiveIndicesNV-OutputTrianglesNV-04344", + "text": " If the {ExecutionMode} is OutputTrianglesNV, then the array decorated with PrimitiveIndicesNV must be the size of three times the value specified by OutputPrimitivesNV" + } + ] + }, + "PrimitiveShadingRateKHR": { + "(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-04484", + "text": " The PrimitiveShadingRateKHR decoration must be used only within the MeshNV, Vertex, or Geometry {ExecutionModel}" + }, + { + "vuid": "VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-04485", + "text": " The variable decorated with PrimitiveShadingRateKHR must be declared using the Output {StorageClass}" + }, + { + "vuid": "VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-04486", + "text": " The variable decorated with PrimitiveShadingRateKHR must be declared as a scalar 32-bit integer value" + }, + { + "vuid": "VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-04487", + "text": " The value written to PrimitiveShadingRateKHR must include no more than one of Vertical2Pixels and Vertical4Pixels" + }, + { + "vuid": "VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-04488", + "text": " The value written to PrimitiveShadingRateKHR must include no more than one of Horizontal2Pixels and Horizontal4Pixels" + }, + { + "vuid": "VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-04489", + "text": " The value written to PrimitiveShadingRateKHR must not have any bits set other than those defined by Fragment Shading Rate Flags enumerants in the SPIR-V specification" + } + ] + }, + "RayGeometryIndexKHR": { + "(VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-RayGeometryIndexKHR-RayGeometryIndexKHR-04345", + "text": " The RayGeometryIndexKHR decoration must be used only within the IntersectionKHR, AnyHitKHR, or ClosestHitKHR {ExecutionModel}" + }, + { + "vuid": "VUID-RayGeometryIndexKHR-RayGeometryIndexKHR-04346", + "text": " The variable decorated with RayGeometryIndexKHR must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-RayGeometryIndexKHR-RayGeometryIndexKHR-04347", + "text": " The variable decorated with RayGeometryIndexKHR must be declared as a scalar 32-bit integer value" + } + ] + }, + "RayTmaxKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-RayTmaxKHR-RayTmaxKHR-04348", + "text": " The RayTmaxKHR decoration must be used only within the IntersectionKHR, AnyHitKHR, ClosestHitKHR, or MissKHR {ExecutionModel}" + }, + { + "vuid": "VUID-RayTmaxKHR-RayTmaxKHR-04349", + "text": " The variable decorated with RayTmaxKHR must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-RayTmaxKHR-RayTmaxKHR-04350", + "text": " The variable decorated with RayTmaxKHR must be declared as a scalar 32-bit floating-point value" + } + ] + }, + "RayTminKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-RayTminKHR-RayTminKHR-04351", + "text": " The RayTminKHR decoration must be used only within the IntersectionKHR, AnyHitKHR, ClosestHitKHR, or MissKHR {ExecutionModel}" + }, + { + "vuid": "VUID-RayTminKHR-RayTminKHR-04352", + "text": " The variable decorated with RayTminKHR must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-RayTminKHR-RayTminKHR-04353", + "text": " The variable decorated with RayTminKHR must be declared as a scalar 32-bit floating-point value" + } + ] + }, + "SampleId": { + "core": [ + { + "vuid": "VUID-SampleId-SampleId-04354", + "text": " The SampleId decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-SampleId-SampleId-04355", + "text": " The variable decorated with SampleId must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-SampleId-SampleId-04356", + "text": " The variable decorated with SampleId must be declared as a scalar 32-bit integer value" + } + ] + }, + "SampleMask": { + "core": [ + { + "vuid": "VUID-SampleMask-SampleMask-04357", + "text": " The SampleMask decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-SampleMask-SampleMask-04358", + "text": " The variable decorated with SampleMask must be declared using the Input or Output {StorageClass}" + }, + { + "vuid": "VUID-SampleMask-SampleMask-04359", + "text": " The variable decorated with SampleMask must be declared as an array of 32-bit integer values" + } + ] + }, + "SamplePosition": { + "core": [ + { + "vuid": "VUID-SamplePosition-SamplePosition-04360", + "text": " The SamplePosition decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-SamplePosition-SamplePosition-04361", + "text": " The variable decorated with SamplePosition must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-SamplePosition-SamplePosition-04362", + "text": " The variable decorated with SamplePosition must be declared as a two-component vector of 32-bit floating-point values" + } + ] + }, + "ShadingRateKHR": { + "(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-ShadingRateKHR-ShadingRateKHR-04490", + "text": " The ShadingRateKHR decoration must be used only within the Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-ShadingRateKHR-ShadingRateKHR-04491", + "text": " The variable decorated with ShadingRateKHR must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-ShadingRateKHR-ShadingRateKHR-04492", + "text": " The variable decorated with ShadingRateKHR must be declared as a scalar 32-bit integer value" + } + ] + }, + "SMCountNV": { + "(VK_NV_shader_sm_builtins)": [ + { + "vuid": "VUID-SMCountNV-SMCountNV-04363", + "text": " The variable decorated with SMCountNV must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-SMCountNV-SMCountNV-04364", + "text": " The variable decorated with SMCountNV must be declared as a scalar 32-bit integer value" + } + ] + }, + "SMIDNV": { + "(VK_NV_shader_sm_builtins)": [ + { + "vuid": "VUID-SMIDNV-SMIDNV-04365", + "text": " The variable decorated with SMIDNV must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-SMIDNV-SMIDNV-04366", + "text": " The variable decorated with SMIDNV must be declared as a scalar 32-bit integer value" + } + ] + }, + "SubgroupId": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-SubgroupId-SubgroupId-04367", + "text": " The SubgroupId decoration must be used only within the GLCompute, MeshNV, or TaskNV {ExecutionModel}" + }, + { + "vuid": "VUID-SubgroupId-SubgroupId-04368", + "text": " The variable decorated with SubgroupId must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-SubgroupId-SubgroupId-04369", + "text": " The variable decorated with SubgroupId must be declared as a scalar 32-bit integer value" + } + ] + }, + "SubgroupEqMask": { + "(VK_VERSION_1_1,VK_EXT_shader_subgroup_ballot)": [ + { + "vuid": "VUID-SubgroupEqMask-SubgroupEqMask-04370", + "text": " The variable decorated with SubgroupEqMask must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-SubgroupEqMask-SubgroupEqMask-04371", + "text": " The variable decorated with SubgroupEqMask must be declared as a four-component vector of 32-bit integer values" + } + ] + }, + "SubgroupGeMask": { + "(VK_VERSION_1_1,VK_EXT_shader_subgroup_ballot)": [ + { + "vuid": "VUID-SubgroupGeMask-SubgroupGeMask-04372", + "text": " The variable decorated with SubgroupGeMask must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-SubgroupGeMask-SubgroupGeMask-04373", + "text": " The variable decorated with SubgroupGeMask must be declared as a four-component vector of 32-bit integer values" + } + ] + }, + "SubgroupGtMask": { + "(VK_VERSION_1_1,VK_EXT_shader_subgroup_ballot)": [ + { + "vuid": "VUID-SubgroupGtMask-SubgroupGtMask-04374", + "text": " The variable decorated with SubgroupGtMask must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-SubgroupGtMask-SubgroupGtMask-04375", + "text": " The variable decorated with SubgroupGtMask must be declared as a four-component vector of 32-bit integer values" + } + ] + }, + "SubgroupLeMask": { + "(VK_VERSION_1_1,VK_EXT_shader_subgroup_ballot)": [ + { + "vuid": "VUID-SubgroupLeMask-SubgroupLeMask-04376", + "text": " The variable decorated with SubgroupLeMask must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-SubgroupLeMask-SubgroupLeMask-04377", + "text": " The variable decorated with SubgroupLeMask must be declared as a four-component vector of 32-bit integer values" + } + ] + }, + "SubgroupLtMask": { + "(VK_VERSION_1_1,VK_EXT_shader_subgroup_ballot)": [ + { + "vuid": "VUID-SubgroupLtMask-SubgroupLtMask-04378", + "text": " The variable decorated with SubgroupLtMask must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-SubgroupLtMask-SubgroupLtMask-04379", + "text": " The variable decorated with SubgroupLtMask must be declared as a four-component vector of 32-bit integer values" + } + ] + }, + "SubgroupLocalInvocationId": { + "(VK_VERSION_1_1,VK_EXT_shader_subgroup_ballot)": [ + { + "vuid": "VUID-SubgroupLocalInvocationId-SubgroupLocalInvocationId-04380", + "text": " The variable decorated with SubgroupLocalInvocationId must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-SubgroupLocalInvocationId-SubgroupLocalInvocationId-04381", + "text": " The variable decorated with SubgroupLocalInvocationId must be declared as a scalar 32-bit integer value" + } + ] + }, + "SubgroupSize": { + "(VK_VERSION_1_1,VK_EXT_shader_subgroup_ballot)": [ + { + "vuid": "VUID-SubgroupSize-SubgroupSize-04382", + "text": " The variable decorated with SubgroupSize must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-SubgroupSize-SubgroupSize-04383", + "text": " The variable decorated with SubgroupSize must be declared as a scalar 32-bit integer value" + } + ] + }, + "TaskCountNV": { + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-TaskCountNV-TaskCountNV-04384", + "text": " The TaskCountNV decoration must be used only within the TaskNV {ExecutionModel}" + }, + { + "vuid": "VUID-TaskCountNV-TaskCountNV-04385", + "text": " The variable decorated with TaskCountNV must be declared using the Output {StorageClass}" + }, + { + "vuid": "VUID-TaskCountNV-TaskCountNV-04386", + "text": " The variable decorated with TaskCountNV must be declared as a scalar 32-bit integer value" + } + ] + }, + "TessCoord": { + "core": [ + { + "vuid": "VUID-TessCoord-TessCoord-04387", + "text": " The TessCoord decoration must be used only within the TessellationEvaluation {ExecutionModel}" + }, + { + "vuid": "VUID-TessCoord-TessCoord-04388", + "text": " The variable decorated with TessCoord must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-TessCoord-TessCoord-04389", + "text": " The variable decorated with TessCoord must be declared as a three-component vector of 32-bit floating-point values" + } + ] + }, + "TessLevelOuter": { + "core": [ + { + "vuid": "VUID-TessLevelOuter-TessLevelOuter-04390", + "text": " The TessLevelOuter decoration must be used only within the TessellationControl or TessellationEvaluation {ExecutionModel}" + }, + { + "vuid": "VUID-TessLevelOuter-TessLevelOuter-04391", + "text": " The variable decorated with TessLevelOuter within the TessellationControl {ExecutionModel} must be declared using the Output {StorageClass}" + }, + { + "vuid": "VUID-TessLevelOuter-TessLevelOuter-04392", + "text": " The variable decorated with TessLevelOuter within the TessellationEvaluation {ExecutionModel} must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-TessLevelOuter-TessLevelOuter-04393", + "text": " The variable decorated with TessLevelOuter must be declared as an array of size four, containing 32-bit floating-point values" + } + ] + }, + "TessLevelInner": { + "core": [ + { + "vuid": "VUID-TessLevelInner-TessLevelInner-04394", + "text": " The TessLevelInner decoration must be used only within the TessellationControl or TessellationEvaluation {ExecutionModel}" + }, + { + "vuid": "VUID-TessLevelInner-TessLevelInner-04395", + "text": " The variable decorated with TessLevelInner within the TessellationControl {ExecutionModel} must be declared using the Output {StorageClass}" + }, + { + "vuid": "VUID-TessLevelInner-TessLevelInner-04396", + "text": " The variable decorated with TessLevelInner within the TessellationEvaluation {ExecutionModel} must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-TessLevelInner-TessLevelInner-04397", + "text": " The variable decorated with TessLevelInner must be declared as an array of size two, containing 32-bit floating-point values" + } + ] + }, + "VertexIndex": { + "core": [ + { + "vuid": "VUID-VertexIndex-VertexIndex-04398", + "text": " The VertexIndex decoration must be used only within the Vertex {ExecutionModel}" + }, + { + "vuid": "VUID-VertexIndex-VertexIndex-04399", + "text": " The variable decorated with VertexIndex must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-VertexIndex-VertexIndex-04400", + "text": " The variable decorated with VertexIndex must be declared as a scalar 32-bit integer value" + } + ] + }, + "ViewIndex": { + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-ViewIndex-ViewIndex-04401", + "text": " The ViewIndex decoration must not be used within the GLCompute {ExecutionModel}" + }, + { + "vuid": "VUID-ViewIndex-ViewIndex-04402", + "text": " The variable decorated with ViewIndex must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-ViewIndex-ViewIndex-04403", + "text": " The variable decorated with ViewIndex must be declared as a scalar 32-bit integer value" + } + ] + }, + "ViewportIndex": { + "core": [ + { + "vuid": "VUID-ViewportIndex-ViewportIndex-04404", + "text": " The ViewportIndex decoration must be used only within the MeshNV, Vertex, TessellationEvaluation, Geometry, or Fragment {ExecutionModel}" + }, + { + "vuid": "VUID-ViewportIndex-ViewportIndex-04406", + "text": " The variable decorated with ViewportIndex within the MeshNV, Vertex, TessellationEvaluation, or Geometry {ExecutionModel} must be declared using the Output {StorageClass}" + }, + { + "vuid": "VUID-ViewportIndex-ViewportIndex-04407", + "text": " The variable decorated with ViewportIndex within the Fragment {ExecutionModel} must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-ViewportIndex-ViewportIndex-04408", + "text": " The variable decorated with ViewportIndex must be declared as a scalar 32-bit integer value" + } + ], + "(VK_VERSION_1_2)": [ + { + "vuid": "VUID-ViewportIndex-ViewportIndex-04405", + "text": " If the shaderOutputViewportIndex feature is not enabled then the ViewportIndex decoration must be used only within the Geometry or Fragment {ExecutionModel}" + } + ] + }, + "ViewportMaskNV": { + "(VK_NV_viewport_array2)": [ + { + "vuid": "VUID-ViewportMaskNV-ViewportMaskNV-04409", + "text": " The ViewportMaskNV decoration must be used only within the Vertex, MeshNV, TessellationEvaluation, or Geometry {ExecutionModel}" + }, + { + "vuid": "VUID-ViewportMaskNV-ViewportMaskNV-04410", + "text": " The variable decorated with ViewportMaskNV must be declared using the Output {StorageClass}" + }, + { + "vuid": "VUID-ViewportMaskNV-ViewportMaskNV-04411", + "text": " The variable decorated with ViewportMaskNV must be declared as an array of 32-bit integer values" + } + ] + }, + "ViewportMaskPerViewNV": { + "(VK_NVX_multiview_per_view_attributes+VK_NV_viewport_array2)": [ + { + "vuid": "VUID-ViewportMaskPerViewNV-ViewportMaskPerViewNV-04412", + "text": " The ViewportMaskPerViewNV decoration must be used only within the Vertex, MeshNV, TessellationControl, TessellationEvaluation, or Geometry {ExecutionModel}" + }, + { + "vuid": "VUID-ViewportMaskPerViewNV-ViewportMaskPerViewNV-04413", + "text": " The variable decorated with ViewportMaskPerViewNV must be declared using the Output {StorageClass}" + }, + { + "vuid": "VUID-ViewportMaskPerViewNV-ViewportMaskPerViewNV-04414", + "text": " The variable decorated with ViewportMaskPerViewNV must be declared as an array of 32-bit integer values" + }, + { + "vuid": "VUID-ViewportMaskPerViewNV-ViewportMaskPerViewNV-04415", + "text": " The array decorated with ViewportMaskPerViewNV must be a size less than or equal to 32" + }, + { + "vuid": "VUID-ViewportMaskPerViewNV-ViewportMaskPerViewNV-04416", + "text": " The array decorated with ViewportMaskPerViewNV must be a size greater than the maximum view in the subpass’s view mask" + }, + { + "vuid": "VUID-ViewportMaskPerViewNV-ViewportMaskPerViewNV-04417", + "text": " The array variable decorated with ViewportMaskPerViewNV must only be indexed by a constant or specialization constant" + } + ] + }, + "WarpsPerSMNV": { + "(VK_NV_shader_sm_builtins)": [ + { + "vuid": "VUID-WarpsPerSMNV-WarpsPerSMNV-04418", + "text": " The variable decorated with WarpsPerSMNV must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-WarpsPerSMNV-WarpsPerSMNV-04419", + "text": " The variable decorated with WarpsPerSMNV must be declared as a scalar 32-bit integer value" + } + ] + }, + "WarpIDNV": { + "(VK_NV_shader_sm_builtins)": [ + { + "vuid": "VUID-WarpIDNV-WarpIDNV-04420", + "text": " The variable decorated with WarpIDNV must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-WarpIDNV-WarpIDNV-04421", + "text": " The variable decorated with WarpIDNV must be declared as a scalar 32-bit integer value" + } + ] + }, + "WorkgroupId": { + "core": [ + { + "vuid": "VUID-WorkgroupId-WorkgroupId-04422", + "text": " The WorkgroupId decoration must be used only within the GLCompute, MeshNV, or TaskNV {ExecutionModel}" + }, + { + "vuid": "VUID-WorkgroupId-WorkgroupId-04423", + "text": " The variable decorated with WorkgroupId must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-WorkgroupId-WorkgroupId-04424", + "text": " The variable decorated with WorkgroupId must be declared as a three-component vector of 32-bit integer values" + } + ] + }, + "WorkgroupSize": { + "core": [ + { + "vuid": "VUID-WorkgroupSize-WorkgroupSize-04425", + "text": " The WorkgroupSize decoration must be used only within the GLCompute, MeshNV, or TaskNV {ExecutionModel}" + }, + { + "vuid": "VUID-WorkgroupSize-WorkgroupSize-04426", + "text": " The variable decorated with WorkgroupSize must be a specialization constant or a constant" + }, + { + "vuid": "VUID-WorkgroupSize-WorkgroupSize-04427", + "text": " The variable decorated with WorkgroupSize must be declared as a three-component vector of 32-bit integer values" + } + ] + }, + "WorldRayDirectionKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-WorldRayDirectionKHR-WorldRayDirectionKHR-04428", + "text": " The WorldRayDirectionKHR decoration must be used only within the IntersectionKHR, AnyHitKHR, ClosestHitKHR, or MissKHR {ExecutionModel}" + }, + { + "vuid": "VUID-WorldRayDirectionKHR-WorldRayDirectionKHR-04429", + "text": " The variable decorated with WorldRayDirectionKHR must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-WorldRayDirectionKHR-WorldRayDirectionKHR-04430", + "text": " The variable decorated with WorldRayDirectionKHR must be declared as a three-component vector of 32-bit floating-point values" + } + ] + }, + "WorldRayOriginKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-WorldRayOriginKHR-WorldRayOriginKHR-04431", + "text": " The WorldRayOriginKHR decoration must be used only within the IntersectionKHR, AnyHitKHR, ClosestHitKHR, or MissKHR {ExecutionModel}" + }, + { + "vuid": "VUID-WorldRayOriginKHR-WorldRayOriginKHR-04432", + "text": " The variable decorated with WorldRayOriginKHR must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-WorldRayOriginKHR-WorldRayOriginKHR-04433", + "text": " The variable decorated with WorldRayOriginKHR must be declared as a three-component vector of 32-bit floating-point values" + } + ] + }, + "WorldToObjectKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-WorldToObjectKHR-WorldToObjectKHR-04434", + "text": " The WorldToObjectKHR decoration must be used only within the IntersectionKHR, AnyHitKHR, or ClosestHitKHR {ExecutionModel}" + }, + { + "vuid": "VUID-WorldToObjectKHR-WorldToObjectKHR-04435", + "text": " The variable decorated with WorldToObjectKHR must be declared using the Input {StorageClass}" + }, + { + "vuid": "VUID-WorldToObjectKHR-WorldToObjectKHR-04436", + "text": " The variable decorated with WorldToObjectKHR must be declared as a matrix with four columns of three-component vectors of 32-bit floating-point values" + } + ] + }, + "vkCreateQueryPool": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateQueryPool-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "core": [ + { + "vuid": "VUID-vkCreateQueryPool-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateQueryPool-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkQueryPoolCreateInfo structure" + }, + { + "vuid": "VUID-vkCreateQueryPool-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateQueryPool-pQueryPool-parameter", + "text": " pQueryPool must be a valid pointer to a VkQueryPool handle" + } + ] + }, + "VkQueryPoolCreateInfo": { + "core": [ + { + "vuid": "VUID-VkQueryPoolCreateInfo-queryType-00791", + "text": " If the pipeline statistics queries feature is not enabled, queryType must not be VK_QUERY_TYPE_PIPELINE_STATISTICS" + }, + { + "vuid": "VUID-VkQueryPoolCreateInfo-queryType-00792", + "text": " If queryType is VK_QUERY_TYPE_PIPELINE_STATISTICS, pipelineStatistics must be a valid combination of VkQueryPipelineStatisticFlagBits values" + }, + { + "vuid": "VUID-VkQueryPoolCreateInfo-queryCount-02763", + "text": " queryCount must be greater than 0" + }, + { + "vuid": "VUID-VkQueryPoolCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO" + }, + { + "vuid": "VUID-VkQueryPoolCreateInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkQueryPoolPerformanceCreateInfoKHR" + }, + { + "vuid": "VUID-VkQueryPoolCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkQueryPoolCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkQueryPoolCreateInfo-queryType-parameter", + "text": " queryType must be a valid VkQueryType value" + } + ], + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-VkQueryPoolCreateInfo-queryType-03222", + "text": " If queryType is VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, the pNext chain must include a VkQueryPoolPerformanceCreateInfoKHR structure" + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkQueryPoolCreateInfo-queryType-05046", + "text": " If queryType is VK_QUERY_TYPE_OCCLUSION then queryCount must be less than or equal to the maximum of all VkDeviceObjectReservationCreateInfo::maxOcclusionQueriesPerPool values specified when device was created" + }, + { + "vuid": "VUID-VkQueryPoolCreateInfo-queryType-05047", + "text": " If queryType is VK_QUERY_TYPE_PIPELINE_STATISTICS then queryCount must be less than or equal to the maximum of all VkDeviceObjectReservationCreateInfo::maxPipelineStatisticsQueriesPerPool values specified when device was created" + }, + { + "vuid": "VUID-VkQueryPoolCreateInfo-queryType-05048", + "text": " If queryType is VK_QUERY_TYPE_TIMESTAMP then queryCount must be less than or equal to the maximum of all VkDeviceObjectReservationCreateInfo::maxTimestampQueriesPerPool values specified when device was created" + } + ], + "(VKSC_VERSION_1_0)+(VK_KHR_performance_query)": [ + { + "vuid": "VUID-VkQueryPoolCreateInfo-queryType-05049", + "text": " If queryType is VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR then queryCount must be less than or equal to the maximum of all VkPerformanceQueryReservationInfoKHR::maxPerformanceQueriesPerPool values specified when device was created" + } + ] + }, + "VkQueryPoolPerformanceCreateInfoKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-VkQueryPoolPerformanceCreateInfoKHR-queueFamilyIndex-03236", + "text": " queueFamilyIndex must be a valid queue family index of the device" + }, + { + "vuid": "VUID-VkQueryPoolPerformanceCreateInfoKHR-performanceCounterQueryPools-03237", + "text": " The performanceCounterQueryPools feature must be enabled" + }, + { + "vuid": "VUID-VkQueryPoolPerformanceCreateInfoKHR-pCounterIndices-03321", + "text": " Each element of pCounterIndices must be in the range of counters reported by vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR for the queue family specified in queueFamilyIndex" + }, + { + "vuid": "VUID-VkQueryPoolPerformanceCreateInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR" + }, + { + "vuid": "VUID-VkQueryPoolPerformanceCreateInfoKHR-pCounterIndices-parameter", + "text": " pCounterIndices must be a valid pointer to an array of counterIndexCount uint32_t values" + }, + { + "vuid": "VUID-VkQueryPoolPerformanceCreateInfoKHR-counterIndexCount-arraylength", + "text": " counterIndexCount must be greater than 0" + } + ] + }, + "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR-pPerformanceQueryCreateInfo-parameter", + "text": " pPerformanceQueryCreateInfo must be a valid pointer to a valid VkQueryPoolPerformanceCreateInfoKHR structure" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR-pNumPasses-parameter", + "text": " pNumPasses must be a valid pointer to a uint32_t value" + } + ] + }, + "vkDestroyQueryPool": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyQueryPool-queryPool-00793", + "text": " All submitted commands that refer to queryPool must have completed execution" + }, + { + "vuid": "VUID-vkDestroyQueryPool-queryPool-00794", + "text": " If VkAllocationCallbacks were provided when queryPool was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyQueryPool-queryPool-00795", + "text": " If no VkAllocationCallbacks were provided when queryPool was created, pAllocator must be NULL" + } + ] + }, + "vkCmdResetQueryPool": { + "core": [ + { + "vuid": "VUID-vkCmdResetQueryPool-firstQuery-00796", + "text": " firstQuery must be less than the number of queries in queryPool" + }, + { + "vuid": "VUID-vkCmdResetQueryPool-firstQuery-00797", + "text": " The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool" + }, + { + "vuid": "VUID-vkCmdResetQueryPool-None-02841", + "text": " All queries used by the command must not be active" + }, + { + "vuid": "VUID-vkCmdResetQueryPool-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdResetQueryPool-queryPool-parameter", + "text": " queryPool must be a valid VkQueryPool handle" + }, + { + "vuid": "VUID-vkCmdResetQueryPool-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdResetQueryPool-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdResetQueryPool-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdResetQueryPool-commonparent", + "text": " Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkCmdResetQueryPool-firstQuery-02862", + "text": " If queryPool was created with VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, this command must not be recorded in a command buffer that, either directly or through secondary command buffers, also contains begin commands for a query from the set of queries [firstQuery, firstQuery + queryCount - 1]" + } + ] + }, + "vkResetQueryPool": { + "(VK_VERSION_1_2,VK_EXT_host_query_reset)": [ + { + "vuid": "VUID-vkResetQueryPool-None-02665", + "text": " The hostQueryReset feature must be enabled" + }, + { + "vuid": "VUID-vkResetQueryPool-firstQuery-02666", + "text": " firstQuery must be less than the number of queries in queryPool" + }, + { + "vuid": "VUID-vkResetQueryPool-firstQuery-02667", + "text": " The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool" + }, + { + "vuid": "VUID-vkResetQueryPool-firstQuery-02741", + "text": " Submitted commands that refer to the range specified by firstQuery and queryCount in queryPool must have completed execution" + }, + { + "vuid": "VUID-vkResetQueryPool-firstQuery-02742", + "text": " The range of queries specified by firstQuery and queryCount in queryPool must not be in use by calls to vkGetQueryPoolResults or vkResetQueryPool in other threads" + }, + { + "vuid": "VUID-vkResetQueryPool-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkResetQueryPool-queryPool-parameter", + "text": " queryPool must be a valid VkQueryPool handle" + }, + { + "vuid": "VUID-vkResetQueryPool-queryPool-parent", + "text": " queryPool must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCmdBeginQuery": { + "core": [ + { + "vuid": "VUID-vkCmdBeginQuery-None-00807", + "text": " All queries used by the command must be unavailable" + }, + { + "vuid": "VUID-vkCmdBeginQuery-queryType-02804", + "text": " The queryType used to create queryPool must not be VK_QUERY_TYPE_TIMESTAMP" + }, + { + "vuid": "VUID-vkCmdBeginQuery-queryType-00800", + "text": " If the precise occlusion queries feature is not enabled, or the queryType used to create queryPool was not VK_QUERY_TYPE_OCCLUSION, flags must not contain VK_QUERY_CONTROL_PRECISE_BIT" + }, + { + "vuid": "VUID-vkCmdBeginQuery-query-00802", + "text": " query must be less than the number of queries in queryPool" + }, + { + "vuid": "VUID-vkCmdBeginQuery-queryType-00803", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_OCCLUSION, the VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBeginQuery-queryType-00804", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pipelineStatistics indicate graphics operations, the VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBeginQuery-queryType-00805", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pipelineStatistics indicate compute operations, the VkCommandPool that commandBuffer was allocated from must support compute operations" + }, + { + "vuid": "VUID-vkCmdBeginQuery-queryPool-01922", + "text": " queryPool must have been created with a queryType that differs from that of any queries that are active within commandBuffer" + }, + { + "vuid": "VUID-vkCmdBeginQuery-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdBeginQuery-queryPool-parameter", + "text": " queryPool must be a valid VkQueryPool handle" + }, + { + "vuid": "VUID-vkCmdBeginQuery-flags-parameter", + "text": " flags must be a valid combination of VkQueryControlFlagBits values" + }, + { + "vuid": "VUID-vkCmdBeginQuery-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdBeginQuery-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdBeginQuery-commonparent", + "text": " Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCmdBeginQuery-queryType-04728", + "text": " The queryType used to create queryPool must not be VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR or VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR" + } + ], + "(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-vkCmdBeginQuery-queryType-04729", + "text": " The queryType used to create queryPool must not be VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdBeginQuery-commandBuffer-01885", + "text": " commandBuffer must not be a protected command buffer" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdBeginQuery-query-00808", + "text": " If called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool" + } + ], + "(VK_KHR_video_encode_queue)": [ + { + "vuid": "VUID-vkCmdBeginQuery-queryType-04862", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR the VkCommandPool that commandBuffer was allocated from must support video encode operations" + } + ], + "(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdBeginQuery-queryType-02327", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT the VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBeginQuery-queryType-02328", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT then VkPhysicalDeviceTransformFeedbackPropertiesEXT::transformFeedbackQueries must be supported" + } + ], + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkCmdBeginQuery-queryPool-03223", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, the profiling lock must have been held before vkBeginCommandBuffer was called on commandBuffer" + }, + { + "vuid": "VUID-vkCmdBeginQuery-queryPool-03224", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and one of the counters used to create queryPool was VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, the query begin must be the first recorded command in commandBuffer" + }, + { + "vuid": "VUID-vkCmdBeginQuery-queryPool-03225", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and one of the counters used to create queryPool was VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, the begin command must not be recorded within a render pass instance" + }, + { + "vuid": "VUID-vkCmdBeginQuery-queryPool-03226", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and another query pool with a queryType VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR has been used within commandBuffer, its parent primary command buffer or secondary command buffer recorded within the same parent primary command buffer as commandBuffer, the performanceCounterMultipleQueryPools feature must be enabled" + }, + { + "vuid": "VUID-vkCmdBeginQuery-None-02863", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, this command must not be recorded in a command buffer that, either directly or through secondary command buffers, also contains a vkCmdResetQueryPool command affecting the same query" + } + ] + }, + "vkCmdBeginQueryIndexedEXT": { + "(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-None-00807", + "text": " All queries used by the command must be unavailable" + }, + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryType-02804", + "text": " The queryType used to create queryPool must not be VK_QUERY_TYPE_TIMESTAMP" + }, + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryType-00800", + "text": " If the precise occlusion queries feature is not enabled, or the queryType used to create queryPool was not VK_QUERY_TYPE_OCCLUSION, flags must not contain VK_QUERY_CONTROL_PRECISE_BIT" + }, + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-query-00802", + "text": " query must be less than the number of queries in queryPool" + }, + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryType-00803", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_OCCLUSION, the VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryType-00804", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pipelineStatistics indicate graphics operations, the VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryType-00805", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pipelineStatistics indicate compute operations, the VkCommandPool that commandBuffer was allocated from must support compute operations" + }, + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryPool-04753", + "text": " If the queryPool was created with the same queryType as that of another active query within commandBuffer, then index must not match the index used for the active query" + }, + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryType-02338", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT the VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryType-02339", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT the index parameter must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreams" + }, + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryType-02340", + "text": " If the queryType used to create queryPool was not VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT the index must be zero" + }, + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryType-02341", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT then VkPhysicalDeviceTransformFeedbackPropertiesEXT::transformFeedbackQueries must be supported" + } + ], + "(VK_EXT_transform_feedback)+(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryType-04728", + "text": " The queryType used to create queryPool must not be VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR or VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR" + } + ], + "(VK_EXT_transform_feedback)+(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryType-04729", + "text": " The queryType used to create queryPool must not be VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV" + } + ], + "(VK_EXT_transform_feedback)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-commandBuffer-01885", + "text": " commandBuffer must not be a protected command buffer" + } + ], + "(VK_EXT_transform_feedback)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-query-00808", + "text": " If called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool" + } + ], + "(VK_EXT_transform_feedback)+(VK_KHR_video_encode_queue)": [ + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryType-04862", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR the VkCommandPool that commandBuffer was allocated from must support video encode operations" + } + ], + "(VK_EXT_transform_feedback)+(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryPool-03223", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, the profiling lock must have been held before vkBeginCommandBuffer was called on commandBuffer" + }, + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryPool-03224", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and one of the counters used to create queryPool was VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, the query begin must be the first recorded command in commandBuffer" + }, + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryPool-03225", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and one of the counters used to create queryPool was VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, the begin command must not be recorded within a render pass instance" + }, + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryPool-03226", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and another query pool with a queryType VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR has been used within commandBuffer, its parent primary command buffer or secondary command buffer recorded within the same parent primary command buffer as commandBuffer, the performanceCounterMultipleQueryPools feature must be enabled" + }, + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-None-02863", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, this command must not be recorded in a command buffer that, either directly or through secondary command buffers, also contains a vkCmdResetQueryPool command affecting the same query" + } + ] + }, + "vkCmdEndQuery": { + "core": [ + { + "vuid": "VUID-vkCmdEndQuery-None-01923", + "text": " All queries used by the command must be active" + }, + { + "vuid": "VUID-vkCmdEndQuery-query-00810", + "text": " query must be less than the number of queries in queryPool" + }, + { + "vuid": "VUID-vkCmdEndQuery-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdEndQuery-queryPool-parameter", + "text": " queryPool must be a valid VkQueryPool handle" + }, + { + "vuid": "VUID-vkCmdEndQuery-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdEndQuery-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdEndQuery-commonparent", + "text": " Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdEndQuery-commandBuffer-01886", + "text": " commandBuffer must not be a protected command buffer" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdEndQuery-query-00812", + "text": " If vkCmdEndQuery is called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool" + } + ], + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkCmdEndQuery-queryPool-03227", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and one or more of the counters used to create queryPool was VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, the vkCmdEndQuery must be the last recorded command in commandBuffer" + }, + { + "vuid": "VUID-vkCmdEndQuery-queryPool-03228", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and one or more of the counters used to create queryPool was VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, the vkCmdEndQuery must not be recorded within a render pass instance" + } + ] + }, + "vkCmdEndQueryIndexedEXT": { + "(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdEndQueryIndexedEXT-None-02342", + "text": " All queries used by the command must be active" + }, + { + "vuid": "VUID-vkCmdEndQueryIndexedEXT-query-02343", + "text": " query must be less than the number of queries in queryPool" + }, + { + "vuid": "VUID-vkCmdEndQueryIndexedEXT-queryType-02346", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT the index parameter must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreams" + }, + { + "vuid": "VUID-vkCmdEndQueryIndexedEXT-queryType-02347", + "text": " If the queryType used to create queryPool was not VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT the index must be zero" + }, + { + "vuid": "VUID-vkCmdEndQueryIndexedEXT-queryType-02723", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT index must equal the index used to begin the query" + } + ], + "(VK_EXT_transform_feedback)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdEndQueryIndexedEXT-commandBuffer-02344", + "text": " commandBuffer must not be a protected command buffer" + } + ], + "(VK_EXT_transform_feedback)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdEndQueryIndexedEXT-query-02345", + "text": " If vkCmdEndQueryIndexedEXT is called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool" + } + ] + }, + "vkGetQueryPoolResults": { + "core": [ + { + "vuid": "VUID-vkGetQueryPoolResults-firstQuery-00813", + "text": " firstQuery must be less than the number of queries in queryPool" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-flags-00815", + "text": " If VK_QUERY_RESULT_64_BIT is set in flags then pData and stride must be multiples of 8" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-firstQuery-00816", + "text": " The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-dataSize-00817", + "text": " dataSize must be large enough to contain the result of each query, as described here" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-queryType-00818", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_TIMESTAMP, flags must not contain VK_QUERY_RESULT_PARTIAL_BIT" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-queryPool-parameter", + "text": " queryPool must be a valid VkQueryPool handle" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-pData-parameter", + "text": " pData must be a valid pointer to an array of dataSize bytes" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-flags-parameter", + "text": " flags must be a valid combination of VkQueryResultFlagBits values" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-dataSize-arraylength", + "text": " dataSize must be greater than 0" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-queryPool-parent", + "text": " queryPool must have been created, allocated, or retrieved from device" + } + ], + "!(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkGetQueryPoolResults-flags-02827", + "text": " If VK_QUERY_RESULT_64_BIT is not set in flags, then pData and stride must be multiples of 4" + } + ], + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkGetQueryPoolResults-flags-02828", + "text": " If VK_QUERY_RESULT_64_BIT is not set in flags and the queryType used to create queryPool was not VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, then pData and stride must be multiples of 4" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-queryType-03229", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, then pData and stride must be multiples of the size of VkPerformanceCounterResultKHR" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-queryType-04519", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, then stride must be large enough to contain VkQueryPoolPerformanceCreateInfoKHR::counterIndexCount used to create queryPool times the size of VkPerformanceCounterResultKHR" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-queryType-03230", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, flags must not contain VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, VK_QUERY_RESULT_PARTIAL_BIT or VK_QUERY_RESULT_64_BIT" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-queryType-03231", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, the queryPool must have been recorded once for each pass as retrieved via a call to vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR" + } + ], + "(VK_KHR_video_queue)": [ + { + "vuid": "VUID-vkGetQueryPoolResults-queryType-04810", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR, flags must include VK_QUERY_RESULT_WITH_STATUS_BIT_KHR" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-flags-04811", + "text": " If flags includes VK_QUERY_RESULT_WITH_STATUS_BIT_KHR, it must not include VK_QUERY_RESULT_WITH_AVAILABILITY_BIT" + } + ] + }, + "vkCmdCopyQueryPoolResults": { + "core": [ + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-dstOffset-00819", + "text": " dstOffset must be less than the size of dstBuffer" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-firstQuery-00820", + "text": " firstQuery must be less than the number of queries in queryPool" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-firstQuery-00821", + "text": " The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-flags-00822", + "text": " If VK_QUERY_RESULT_64_BIT is not set in flags then dstOffset and stride must be multiples of 4" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-flags-00823", + "text": " If VK_QUERY_RESULT_64_BIT is set in flags then dstOffset and stride must be multiples of 8" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-dstBuffer-00824", + "text": " dstBuffer must have enough storage, from dstOffset, to contain the result of each query, as described here" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-dstBuffer-00825", + "text": " dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-dstBuffer-00826", + "text": " If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-queryType-00827", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_TIMESTAMP, flags must not contain VK_QUERY_RESULT_PARTIAL_BIT" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-queryPool-parameter", + "text": " queryPool must be a valid VkQueryPool handle" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-dstBuffer-parameter", + "text": " dstBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-flags-parameter", + "text": " flags must be a valid combination of VkQueryResultFlagBits values" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-commonparent", + "text": " Each of commandBuffer, dstBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-queryType-03232", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, VkPhysicalDevicePerformanceQueryPropertiesKHR::allowCommandBufferQueryCopies must be VK_TRUE" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-queryType-03233", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, flags must not contain VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, VK_QUERY_RESULT_PARTIAL_BIT or VK_QUERY_RESULT_64_BIT" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-queryType-03234", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, the queryPool must have been submitted once for each pass as retrieved via a call to vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR" + } + ], + "(VK_INTEL_performance_query)": [ + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-queryType-02734", + "text": " vkCmdCopyQueryPoolResults must not be called if the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL" + } + ], + "(VK_KHR_video_queue)": [ + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-queryType-04812", + "text": " vkCmdCopyQueryPoolResults must not be called if the queryType used to create queryPool was VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR or VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR" + } + ] + }, + "vkCmdWriteTimestamp2KHR": { + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-stage-03929", + "text": " If the geometry shaders feature is not enabled, pname:stage must not contain VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-stage-03930", + "text": " If the tessellation shaders feature is not enabled, pname:stage must not contain VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR or VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-synchronization2-03858", + "text": " The synchronization2 feature must be enabled" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-stage-03859", + "text": " stage must only include a single pipeline stage" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-stage-03860", + "text": " stage must only include stages valid for the queue family that was used to create the command pool that commandBuffer was allocated from" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-queryPool-03861", + "text": " queryPool must have been created with a queryType of VK_QUERY_TYPE_TIMESTAMP" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-queryPool-03862", + "text": " The query identified by queryPool and query must be unavailable" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-timestampValidBits-03863", + "text": " The command pool’s queue family must support a non-zero timestampValidBits" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-query-04903", + "text": " query must be less than the number of queries in queryPool" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-stage-parameter", + "text": " stage must be a valid combination of VkPipelineStageFlagBits2KHR values" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-queryPool-parameter", + "text": " queryPool must be a valid VkQueryPool handle" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-commonparent", + "text": " Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_KHR_synchronization2)+(VK_EXT_conditional_rendering)": [ + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-stage-03931", + "text": " If the conditional rendering feature is not enabled, pname:stage must not contain VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT" + } + ], + "(VK_KHR_synchronization2)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-stage-03932", + "text": " If the fragment density map feature is not enabled, pname:stage must not contain VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + } + ], + "(VK_KHR_synchronization2)+(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-stage-03933", + "text": " If the transform feedback feature is not enabled, pname:stage must not contain VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT" + } + ], + "(VK_KHR_synchronization2)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-stage-03934", + "text": " If the mesh shaders feature is not enabled, pname:stage must not contain VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-stage-03935", + "text": " If the task shaders feature is not enabled, pname:stage must not contain VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV" + } + ], + "(VK_KHR_synchronization2)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-stage-04956", + "text": " If the shading rate image feature is not enabled, pname:stage must not contain VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV" + } + ], + "(VK_KHR_synchronization2)+(VK_HUAWEI_subpass_shading)": [ + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-stage-04957", + "text": " If the subpass shading feature is not enabled, pname:stage must not contain VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI" + } + ], + "(VK_KHR_synchronization2)+(VK_HUAWEI_invocation_mask)": [ + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-stage-04995", + "text": " If the invocation mask image feature is not enabled, pname:stage must not contain VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI" + } + ], + "(VK_KHR_synchronization2)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-None-03864", + "text": " All queries used by the command must be unavailable" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp2KHR-query-03865", + "text": " If vkCmdWriteTimestamp2KHR is called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool" + } + ] + }, + "vkCmdWriteTimestamp": { + "core": [ + { + "vuid": "VUID-vkCmdWriteTimestamp-pipelineStage-04074", + "text": " pipelineStage must be a valid stage for the queue family that was used to create the command pool that commandBuffer was allocated from" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-pipelineStage-04075", + "text": " If the geometry shaders feature is not enabled, pipelineStage must not be VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-pipelineStage-04076", + "text": " If the tessellation shaders feature is not enabled, pipelineStage must not be VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-queryPool-01416", + "text": " queryPool must have been created with a queryType of VK_QUERY_TYPE_TIMESTAMP" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-queryPool-00828", + "text": " The query identified by queryPool and query must be unavailable" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-timestampValidBits-00829", + "text": " The command pool’s queue family must support a non-zero timestampValidBits" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-query-04904", + "text": " query must be less than the number of queries in queryPool" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-pipelineStage-parameter", + "text": " pipelineStage must be a valid VkPipelineStageFlagBits value" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-queryPool-parameter", + "text": " queryPool must be a valid VkQueryPool handle" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-commonparent", + "text": " Both of commandBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_EXT_conditional_rendering)": [ + { + "vuid": "VUID-vkCmdWriteTimestamp-pipelineStage-04077", + "text": " If the conditional rendering feature is not enabled, pipelineStage must not be VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT" + } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdWriteTimestamp-pipelineStage-04078", + "text": " If the fragment density map feature is not enabled, pipelineStage must not be VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + } + ], + "(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdWriteTimestamp-pipelineStage-04079", + "text": " If the transform feedback feature is not enabled, pipelineStage must not be VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT" + } + ], + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdWriteTimestamp-pipelineStage-04080", + "text": " If the mesh shaders feature is not enabled, pipelineStage must not be VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV or VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV" + } + ], + "(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdWriteTimestamp-pipelineStage-04081", + "text": " If the shading rate image feature is not enabled, pipelineStage must not be VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV" + } + ], + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkCmdWriteTimestamp-synchronization2-06489", + "text": " If the synchronization2 feature is not enabled, pipelineStage must not be VK_PIPELINE_STAGE_NONE_KHR" + } + ], + "!(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkCmdWriteTimestamp-pipelineStage-06490", + "text": " pipelineStage must not be VK_PIPELINE_STAGE_NONE_KHR" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdWriteTimestamp-None-00830", + "text": " All queries used by the command must be unavailable" + }, + { + "vuid": "VUID-vkCmdWriteTimestamp-query-00831", + "text": " If vkCmdWriteTimestamp is called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool" + } + ] + }, + "vkAcquireProfilingLockKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkAcquireProfilingLockKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkAcquireProfilingLockKHR-pInfo-parameter", + "text": " pInfo must be a valid pointer to a valid VkAcquireProfilingLockInfoKHR structure" + } + ] + }, + "VkAcquireProfilingLockInfoKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-VkAcquireProfilingLockInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR" + }, + { + "vuid": "VUID-VkAcquireProfilingLockInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkAcquireProfilingLockInfoKHR-flags-zerobitmask", + "text": " flags must be 0" + } + ] + }, + "vkReleaseProfilingLockKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkReleaseProfilingLockKHR-device-03235", + "text": " The profiling lock of device must have been held via a previous successful call to vkAcquireProfilingLockKHR" + }, + { + "vuid": "VUID-vkReleaseProfilingLockKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + } + ] + }, + "VkPerformanceStreamMarkerInfoINTEL": { + "(VK_INTEL_performance_query)+(VK_INTEL_performance_query)": [ + { + "vuid": "VUID-VkPerformanceStreamMarkerInfoINTEL-marker-02735", + "text": " The value written by the application into marker must only used the valid bits as reported by vkGetPerformanceParameterINTEL with the VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL" + } + ] + }, + "vkCmdSetPerformanceOverrideINTEL": { + "(VK_INTEL_performance_query)+(VK_INTEL_performance_query)": [ + { + "vuid": "VUID-vkCmdSetPerformanceOverrideINTEL-pOverrideInfo-02736", + "text": " pOverrideInfo must not be used with a VkPerformanceOverrideTypeINTEL that is not reported available by vkGetPerformanceParameterINTEL" + } + ] + }, + "vkReleasePerformanceConfigurationINTEL": { + "(VK_INTEL_performance_query)+(VK_INTEL_performance_query)": [ + { + "vuid": "VUID-vkReleasePerformanceConfigurationINTEL-configuration-02737", + "text": " configuration must not be released before all command buffers submitted while the configuration was set are in pending state" + } + ] + }, + "vkCmdClearColorImage": { + "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-vkCmdClearColorImage-image-01993", + "text": " The format features of image must contain VK_FORMAT_FEATURE_TRANSFER_DST_BIT" + } + ], + "core": [ + { + "vuid": "VUID-vkCmdClearColorImage-image-00002", + "text": " image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdClearColorImage-image-00003", + "text": " If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdClearColorImage-imageLayout-00004", + "text": " imageLayout must specify the layout of the image subresource ranges of image specified in pRanges at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-vkCmdClearColorImage-aspectMask-02498", + "text": " The VkImageSubresourceRange::aspectMask members of the elements of the pRanges array must each only include VK_IMAGE_ASPECT_COLOR_BIT" + }, + { + "vuid": "VUID-vkCmdClearColorImage-baseMipLevel-01470", + "text": " The VkImageSubresourceRange::baseMipLevel members of the elements of the pRanges array must each be less than the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-vkCmdClearColorImage-pRanges-01692", + "text": " For each VkImageSubresourceRange element of pRanges, if the levelCount member is not VK_REMAINING_MIP_LEVELS, then baseMipLevel + levelCount must be less than the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-vkCmdClearColorImage-baseArrayLayer-01472", + "text": " The VkImageSubresourceRange::baseArrayLayer members of the elements of the pRanges array must each be less than the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-vkCmdClearColorImage-pRanges-01693", + "text": " For each VkImageSubresourceRange element of pRanges, if the layerCount member is not VK_REMAINING_ARRAY_LAYERS, then baseArrayLayer + layerCount must be less than the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-vkCmdClearColorImage-image-00007", + "text": " image must not have a compressed or depth/stencil format" + }, + { + "vuid": "VUID-vkCmdClearColorImage-pColor-04961", + "text": " pColor must be a valid pointer to a VkClearColorValue union" + }, + { + "vuid": "VUID-vkCmdClearColorImage-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdClearColorImage-image-parameter", + "text": " image must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkCmdClearColorImage-imageLayout-parameter", + "text": " imageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-vkCmdClearColorImage-pRanges-parameter", + "text": " pRanges must be a valid pointer to an array of rangeCount valid VkImageSubresourceRange structures" + }, + { + "vuid": "VUID-vkCmdClearColorImage-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdClearColorImage-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdClearColorImage-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdClearColorImage-rangeCount-arraylength", + "text": " rangeCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdClearColorImage-commonparent", + "text": " Both of commandBuffer, and image must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkCmdClearColorImage-image-01545", + "text": " image must not use any of the formats that require a sampler Y’CBCR conversion" + } + ], + "!(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdClearColorImage-imageLayout-00005", + "text": " imageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdClearColorImage-imageLayout-01394", + "text": " imageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdClearColorImage-commandBuffer-01805", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, image must not be a protected image" + }, + { + "vuid": "VUID-vkCmdClearColorImage-commandBuffer-01806", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, must not be an unprotected image" + } + ] + }, + "vkCmdClearDepthStencilImage": { + "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-vkCmdClearDepthStencilImage-image-01994", + "text": " The format features of image must contain VK_FORMAT_FEATURE_TRANSFER_DST_BIT" + } + ], + "!(VK_VERSION_1_2,VK_EXT_separate_stencil_usage)": [ + { + "vuid": "VUID-vkCmdClearDepthStencilImage-image-00009", + "text": " image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag" + } + ], + "(VK_VERSION_1_2,VK_EXT_separate_stencil_usage)": [ + { + "vuid": "VUID-vkCmdClearDepthStencilImage-pRanges-02658", + "text": " If the aspect member of any element of pRanges includes VK_IMAGE_ASPECT_STENCIL_BIT, and image was created with separate stencil usage, VK_IMAGE_USAGE_TRANSFER_DST_BIT must have been included in the VkImageStencilUsageCreateInfo::stencilUsage used to create image" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-pRanges-02659", + "text": " If the aspect member of any element of pRanges includes VK_IMAGE_ASPECT_STENCIL_BIT, and image was not created with separate stencil usage, VK_IMAGE_USAGE_TRANSFER_DST_BIT must have been included in the VkImageCreateInfo::usage used to create image" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-pRanges-02660", + "text": " If the aspect member of any element of pRanges includes VK_IMAGE_ASPECT_DEPTH_BIT, VK_IMAGE_USAGE_TRANSFER_DST_BIT must have been included in the VkImageCreateInfo::usage used to create image" + } + ], + "core": [ + { + "vuid": "VUID-vkCmdClearDepthStencilImage-image-00010", + "text": " If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-imageLayout-00011", + "text": " imageLayout must specify the layout of the image subresource ranges of image specified in pRanges at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-imageLayout-00012", + "text": " imageLayout must be either of VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-aspectMask-02824", + "text": " The VkImageSubresourceRange::aspectMask member of each element of the pRanges array must not include bits other than VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-image-02825", + "text": " If the image’s format does not have a stencil component, then the VkImageSubresourceRange::aspectMask member of each element of the pRanges array must not include the VK_IMAGE_ASPECT_STENCIL_BIT bit" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-image-02826", + "text": " If the image’s format does not have a depth component, then the VkImageSubresourceRange::aspectMask member of each element of the pRanges array must not include the VK_IMAGE_ASPECT_DEPTH_BIT bit" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-baseMipLevel-01474", + "text": " The VkImageSubresourceRange::baseMipLevel members of the elements of the pRanges array must each be less than the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-pRanges-01694", + "text": " For each VkImageSubresourceRange element of pRanges, if the levelCount member is not VK_REMAINING_MIP_LEVELS, then baseMipLevel + levelCount must be less than the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-baseArrayLayer-01476", + "text": " The VkImageSubresourceRange::baseArrayLayer members of the elements of the pRanges array must each be less than the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-pRanges-01695", + "text": " For each VkImageSubresourceRange element of pRanges, if the layerCount member is not VK_REMAINING_ARRAY_LAYERS, then baseArrayLayer + layerCount must be less than the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-image-00014", + "text": " image must have a depth/stencil format" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-image-parameter", + "text": " image must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-imageLayout-parameter", + "text": " imageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-pDepthStencil-parameter", + "text": " pDepthStencil must be a valid pointer to a valid VkClearDepthStencilValue structure" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-pRanges-parameter", + "text": " pRanges must be a valid pointer to an array of rangeCount valid VkImageSubresourceRange structures" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-rangeCount-arraylength", + "text": " rangeCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-commonparent", + "text": " Both of commandBuffer, and image must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdClearDepthStencilImage-commandBuffer-01807", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, image must not be a protected image" + }, + { + "vuid": "VUID-vkCmdClearDepthStencilImage-commandBuffer-01808", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, image must not be an unprotected image" + } + ] + }, + "vkCmdClearAttachments": { + "core": [ + { + "vuid": "VUID-vkCmdClearAttachments-aspectMask-02501", + "text": " If the aspectMask member of any element of pAttachments contains VK_IMAGE_ASPECT_COLOR_BIT, then the colorAttachment member of that element must either refer to a color attachment which is VK_ATTACHMENT_UNUSED, or must be a valid color attachment" + }, + { + "vuid": "VUID-vkCmdClearAttachments-aspectMask-02502", + "text": " If the aspectMask member of any element of pAttachments contains VK_IMAGE_ASPECT_DEPTH_BIT, then the current subpass' depth/stencil attachment must either be VK_ATTACHMENT_UNUSED, or must have a depth component" + }, + { + "vuid": "VUID-vkCmdClearAttachments-aspectMask-02503", + "text": " If the aspectMask member of any element of pAttachments contains VK_IMAGE_ASPECT_STENCIL_BIT, then the current subpass' depth/stencil attachment must either be VK_ATTACHMENT_UNUSED, or must have a stencil component" + }, + { + "vuid": "VUID-vkCmdClearAttachments-rect-02682", + "text": " The rect member of each element of pRects must have an extent.width greater than 0" + }, + { + "vuid": "VUID-vkCmdClearAttachments-rect-02683", + "text": " The rect member of each element of pRects must have an extent.height greater than 0" + }, + { + "vuid": "VUID-vkCmdClearAttachments-pRects-00016", + "text": " The rectangular region specified by each element of pRects must be contained within the render area of the current render pass instance" + }, + { + "vuid": "VUID-vkCmdClearAttachments-pRects-00017", + "text": " The layers specified by each element of pRects must be contained within every attachment that pAttachments refers to" + }, + { + "vuid": "VUID-vkCmdClearAttachments-layerCount-01934", + "text": " The layerCount member of each element of pRects must not be 0" + }, + { + "vuid": "VUID-vkCmdClearAttachments-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdClearAttachments-pAttachments-parameter", + "text": " pAttachments must be a valid pointer to an array of attachmentCount valid VkClearAttachment structures" + }, + { + "vuid": "VUID-vkCmdClearAttachments-pRects-parameter", + "text": " pRects must be a valid pointer to an array of rectCount VkClearRect structures" + }, + { + "vuid": "VUID-vkCmdClearAttachments-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdClearAttachments-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdClearAttachments-renderpass", + "text": " This command must only be called inside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdClearAttachments-attachmentCount-arraylength", + "text": " attachmentCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdClearAttachments-rectCount-arraylength", + "text": " rectCount must be greater than 0" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdClearAttachments-commandBuffer-02504", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, each attachment to be cleared must not be a protected image" + }, + { + "vuid": "VUID-vkCmdClearAttachments-commandBuffer-02505", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, each attachment to be cleared must not be an unprotected image" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdClearAttachments-baseArrayLayer-00018", + "text": " If the render pass instance this is recorded in uses multiview, then baseArrayLayer must be zero and layerCount must be one" + } + ] + }, + "VkClearAttachment": { + "core": [ + { + "vuid": "VUID-VkClearAttachment-aspectMask-00019", + "text": " If aspectMask includes VK_IMAGE_ASPECT_COLOR_BIT, it must not include VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT" + }, + { + "vuid": "VUID-VkClearAttachment-aspectMask-00020", + "text": " aspectMask must not include VK_IMAGE_ASPECT_METADATA_BIT" + }, + { + "vuid": "VUID-VkClearAttachment-clearValue-00021", + "text": " clearValue must be a valid VkClearValue union" + }, + { + "vuid": "VUID-VkClearAttachment-aspectMask-parameter", + "text": " aspectMask must be a valid combination of VkImageAspectFlagBits values" + }, + { + "vuid": "VUID-VkClearAttachment-aspectMask-requiredbitmask", + "text": " aspectMask must not be 0" + } + ], + "(VK_EXT_image_drm_format_modifier)": [ + { + "vuid": "VUID-VkClearAttachment-aspectMask-02246", + "text": " aspectMask must not include VK_IMAGE_ASPECT_MEMORY_PLANE{ibit}BIT_EXT for any index i" + } + ] + }, + "VkClearDepthStencilValue": { + "(VK_EXT_depth_range_unrestricted)": [ + { + "vuid": "VUID-VkClearDepthStencilValue-depth-00022", + "text": " Unless the VK_EXT_depth_range_unrestricted extension is enabled depth must be between 0.0 and 1.0, inclusive" + } + ], + "!(VK_EXT_depth_range_unrestricted)": [ + { + "vuid": "VUID-VkClearDepthStencilValue-depth-02506", + "text": " depth must be between 0.0 and 1.0, inclusive" + } + ] + }, + "vkCmdFillBuffer": { + "core": [ + { + "vuid": "VUID-vkCmdFillBuffer-dstOffset-00024", + "text": " dstOffset must be less than the size of dstBuffer" + }, + { + "vuid": "VUID-vkCmdFillBuffer-dstOffset-00025", + "text": " dstOffset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdFillBuffer-size-00026", + "text": " If size is not equal to VK_WHOLE_SIZE, size must be greater than 0" + }, + { + "vuid": "VUID-vkCmdFillBuffer-size-00027", + "text": " If size is not equal to VK_WHOLE_SIZE, size must be less than or equal to the size of dstBuffer minus dstOffset" + }, + { + "vuid": "VUID-vkCmdFillBuffer-size-00028", + "text": " If size is not equal to VK_WHOLE_SIZE, size must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdFillBuffer-dstBuffer-00029", + "text": " dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdFillBuffer-dstBuffer-00031", + "text": " If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdFillBuffer-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdFillBuffer-dstBuffer-parameter", + "text": " dstBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdFillBuffer-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdFillBuffer-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics or compute operations" + }, + { + "vuid": "VUID-vkCmdFillBuffer-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdFillBuffer-commonparent", + "text": " Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "!(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-vkCmdFillBuffer-commandBuffer-00030", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics or compute operations" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdFillBuffer-commandBuffer-01811", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, dstBuffer must not be a protected buffer" + }, + { + "vuid": "VUID-vkCmdFillBuffer-commandBuffer-01812", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, dstBuffer must not be an unprotected buffer" + } + ] + }, + "vkCmdUpdateBuffer": { + "core": [ + { + "vuid": "VUID-vkCmdUpdateBuffer-dstOffset-00032", + "text": " dstOffset must be less than the size of dstBuffer" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-dataSize-00033", + "text": " dataSize must be less than or equal to the size of dstBuffer minus dstOffset" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-dstBuffer-00034", + "text": " dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-dstBuffer-00035", + "text": " If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-dstOffset-00036", + "text": " dstOffset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-dataSize-00037", + "text": " dataSize must be less than or equal to 65536" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-dataSize-00038", + "text": " dataSize must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-dstBuffer-parameter", + "text": " dstBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-pData-parameter", + "text": " pData must be a valid pointer to an array of dataSize bytes" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-dataSize-arraylength", + "text": " dataSize must be greater than 0" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-commonparent", + "text": " Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdUpdateBuffer-commandBuffer-01813", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, dstBuffer must not be a protected buffer" + }, + { + "vuid": "VUID-vkCmdUpdateBuffer-commandBuffer-01814", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, dstBuffer must not be an unprotected buffer" + } + ] + }, + "vkCmdCopyBuffer": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdCopyBuffer-commandBuffer-01822", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, srcBuffer must not be a protected buffer" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-commandBuffer-01823", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, dstBuffer must not be a protected buffer" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-commandBuffer-01824", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, dstBuffer must not be an unprotected buffer" + } + ], + "core": [ + { + "vuid": "VUID-vkCmdCopyBuffer-srcOffset-00113", + "text": " The srcOffset member of each element of pRegions must be less than the size of srcBuffer" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-dstOffset-00114", + "text": " The dstOffset member of each element of pRegions must be less than the size of dstBuffer" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-size-00115", + "text": " The size member of each element of pRegions must be less than or equal to the size of srcBuffer minus srcOffset" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-size-00116", + "text": " The size member of each element of pRegions must be less than or equal to the size of dstBuffer minus dstOffset" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-pRegions-00117", + "text": " The union of the source regions, and the union of the destination regions, specified by the elements of pRegions, must not overlap in memory" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-srcBuffer-00118", + "text": " srcBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-srcBuffer-00119", + "text": " If srcBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-dstBuffer-00120", + "text": " dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-dstBuffer-00121", + "text": " If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-srcBuffer-parameter", + "text": " srcBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-dstBuffer-parameter", + "text": " dstBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-pRegions-parameter", + "text": " pRegions must be a valid pointer to an array of regionCount valid VkBufferCopy structures" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-regionCount-arraylength", + "text": " regionCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdCopyBuffer-commonparent", + "text": " Each of commandBuffer, dstBuffer, and srcBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "VkBufferCopy": { + "core": [ + { + "vuid": "VUID-VkBufferCopy-size-01988", + "text": " The size must be greater than 0" + } + ] + }, + "vkCmdCopyBuffer2KHR": { + "(VK_KHR_copy_commands2)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdCopyBuffer2KHR-commandBuffer-01822", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, srcBuffer must not be a protected buffer" + }, + { + "vuid": "VUID-vkCmdCopyBuffer2KHR-commandBuffer-01823", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, dstBuffer must not be a protected buffer" + }, + { + "vuid": "VUID-vkCmdCopyBuffer2KHR-commandBuffer-01824", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, dstBuffer must not be an unprotected buffer" + } + ], + "(VK_KHR_copy_commands2)": [ + { + "vuid": "VUID-vkCmdCopyBuffer2KHR-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyBuffer2KHR-pCopyBufferInfo-parameter", + "text": " pCopyBufferInfo must be a valid pointer to a valid VkCopyBufferInfo2KHR structure" + }, + { + "vuid": "VUID-vkCmdCopyBuffer2KHR-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdCopyBuffer2KHR-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdCopyBuffer2KHR-renderpass", + "text": " This command must only be called outside of a render pass instance" + } + ] + }, + "VkCopyBufferInfo2KHR": { + "(VK_KHR_copy_commands2)": [ + { + "vuid": "VUID-VkCopyBufferInfo2KHR-srcOffset-00113", + "text": " The srcOffset member of each element of pRegions must be less than the size of srcBuffer" + }, + { + "vuid": "VUID-VkCopyBufferInfo2KHR-dstOffset-00114", + "text": " The dstOffset member of each element of pRegions must be less than the size of dstBuffer" + }, + { + "vuid": "VUID-VkCopyBufferInfo2KHR-size-00115", + "text": " The size member of each element of pRegions must be less than or equal to the size of srcBuffer minus srcOffset" + }, + { + "vuid": "VUID-VkCopyBufferInfo2KHR-size-00116", + "text": " The size member of each element of pRegions must be less than or equal to the size of dstBuffer minus dstOffset" + }, + { + "vuid": "VUID-VkCopyBufferInfo2KHR-pRegions-00117", + "text": " The union of the source regions, and the union of the destination regions, specified by the elements of pRegions, must not overlap in memory" + }, + { + "vuid": "VUID-VkCopyBufferInfo2KHR-srcBuffer-00118", + "text": " srcBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag" + }, + { + "vuid": "VUID-VkCopyBufferInfo2KHR-srcBuffer-00119", + "text": " If srcBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkCopyBufferInfo2KHR-dstBuffer-00120", + "text": " dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-VkCopyBufferInfo2KHR-dstBuffer-00121", + "text": " If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkCopyBufferInfo2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR" + }, + { + "vuid": "VUID-VkCopyBufferInfo2KHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkCopyBufferInfo2KHR-srcBuffer-parameter", + "text": " srcBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-VkCopyBufferInfo2KHR-dstBuffer-parameter", + "text": " dstBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-VkCopyBufferInfo2KHR-pRegions-parameter", + "text": " pRegions must be a valid pointer to an array of regionCount valid VkBufferCopy2KHR structures" + }, + { + "vuid": "VUID-VkCopyBufferInfo2KHR-regionCount-arraylength", + "text": " regionCount must be greater than 0" + }, + { + "vuid": "VUID-VkCopyBufferInfo2KHR-commonparent", + "text": " Both of dstBuffer, and srcBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ] + }, + "VkBufferCopy2KHR": { + "(VK_KHR_copy_commands2)": [ + { + "vuid": "VUID-VkBufferCopy2KHR-size-01988", + "text": " The size must be greater than 0" + }, + { + "vuid": "VUID-VkBufferCopy2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR" + }, + { + "vuid": "VUID-VkBufferCopy2KHR-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkCmdCopyImage": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdCopyImage-commandBuffer-01825", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, srcImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdCopyImage-commandBuffer-01826", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, dstImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdCopyImage-commandBuffer-01827", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, dstImage must not be an unprotected image" + } + ], + "core": [ + { + "vuid": "VUID-vkCmdCopyImage-pRegions-00124", + "text": " The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-00126", + "text": " srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImageLayout-00128", + "text": " srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-00131", + "text": " dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImageLayout-00133", + "text": " dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-00136", + "text": " The sample count of srcImage and dstImage must match" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcSubresource-01696", + "text": " The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstSubresource-01697", + "text": " The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcSubresource-01698", + "text": " The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstSubresource-01699", + "text": " The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcOffset-01783", + "text": " The srcOffset and extent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstOffset-01784", + "text": " The dstOffset and extent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties" + }, + { + "vuid": "VUID-vkCmdCopyImage-aspectMask-00142", + "text": " For each element of pRegions, srcSubresource.aspectMask must specify aspects present in srcImage" + }, + { + "vuid": "VUID-vkCmdCopyImage-aspectMask-00143", + "text": " For each element of pRegions, dstSubresource.aspectMask must specify aspects present in dstImage" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcOffset-00144", + "text": " For each element of pRegions, srcOffset.x and (extent.width + srcOffset.x) must both be greater than or equal to 0 and less than or equal to the width of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcOffset-00145", + "text": " For each element of pRegions, srcOffset.y and (extent.height + srcOffset.y) must both be greater than or equal to 0 and less than or equal to the height of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-00146", + "text": " If srcImage is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, srcOffset.y must be 0 and extent.height must be 1" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcOffset-00147", + "text": " For each element of pRegions, srcOffset.z and (extent.depth + srcOffset.z) must both be greater than or equal to 0 and less than or equal to the depth of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-01785", + "text": " If srcImage is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, srcOffset.z must be 0 and extent.depth must be 1" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-01786", + "text": " If dstImage is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, dstOffset.z must be 0 and extent.depth must be 1" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-01787", + "text": " If srcImage is of type VK_IMAGE_TYPE_2D, then for each element of pRegions, srcOffset.z must be 0" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-01788", + "text": " If dstImage is of type VK_IMAGE_TYPE_2D, then for each element of pRegions, dstOffset.z must be 0" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstOffset-00150", + "text": " For each element of pRegions, dstOffset.x and (extent.width + dstOffset.x) must both be greater than or equal to 0 and less than or equal to the width of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstOffset-00151", + "text": " For each element of pRegions, dstOffset.y and (extent.height + dstOffset.y) must both be greater than or equal to 0 and less than or equal to the height of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-00152", + "text": " If dstImage is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, dstOffset.y must be 0 and extent.height must be 1" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstOffset-00153", + "text": " For each element of pRegions, dstOffset.z and (extent.depth + dstOffset.z) must both be greater than or equal to 0 and less than or equal to the depth of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-01727", + "text": " If srcImage is a blocked image, then for each element of pRegions, all members of srcOffset must be a multiple of the corresponding dimensions of the compressed texel block" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-01728", + "text": " If srcImage is a blocked image, then for each element of pRegions, extent.width must be a multiple of the compressed texel block width or (extent.width + srcOffset.x) must equal the width of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-01729", + "text": " If srcImage is a blocked image, then for each element of pRegions, extent.height must be a multiple of the compressed texel block height or (extent.height + srcOffset.y) must equal the height of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-01730", + "text": " If srcImage is a blocked image, then for each element of pRegions, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + srcOffset.z) must equal the depth of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-01731", + "text": " If dstImage is a blocked image, then for each element of pRegions, all members of dstOffset must be a multiple of the corresponding dimensions of the compressed texel block" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-01732", + "text": " If dstImage is a blocked image, then for each element of pRegions, extent.width must be a multiple of the compressed texel block width or (extent.width + dstOffset.x) must equal the width of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-01733", + "text": " If dstImage is a blocked image, then for each element of pRegions, extent.height must be a multiple of the compressed texel block height or (extent.height + dstOffset.y) must equal the height of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-01734", + "text": " If dstImage is a blocked image, then for each element of pRegions, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + dstOffset.z) must equal the depth of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-vkCmdCopyImage-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-parameter", + "text": " srcImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImageLayout-parameter", + "text": " srcImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-parameter", + "text": " dstImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImageLayout-parameter", + "text": " dstImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-vkCmdCopyImage-pRegions-parameter", + "text": " pRegions must be a valid pointer to an array of regionCount valid VkImageCopy structures" + }, + { + "vuid": "VUID-vkCmdCopyImage-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdCopyImage-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdCopyImage-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdCopyImage-regionCount-arraylength", + "text": " regionCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdCopyImage-commonparent", + "text": " Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-vkCmdCopyImage-srcImage-01995", + "text": " The format features of srcImage must contain VK_FORMAT_FEATURE_TRANSFER_SRC_BIT" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-01996", + "text": " The format features of dstImage must contain VK_FORMAT_FEATURE_TRANSFER_DST_BIT" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-04443", + "text": " If srcImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, srcSubresource.baseArrayLayer must be 0 and srcSubresource.layerCount must be 1" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-04444", + "text": " If dstImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, dstSubresource.baseArrayLayer must be 0 and dstSubresource.layerCount must be 1" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-01790", + "text": " If srcImage and dstImage are both of type VK_IMAGE_TYPE_2D, then for each element of pRegions, extent.depth must be 1" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-01791", + "text": " If srcImage is of type VK_IMAGE_TYPE_2D, and dstImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, extent.depth must equal srcSubresource.layerCount" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-01792", + "text": " If dstImage is of type VK_IMAGE_TYPE_2D, and srcImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, extent.depth must equal dstSubresource.layerCount" + } + ], + "!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkCmdCopyImage-srcImage-00127", + "text": " If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-00132", + "text": " If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-00135", + "text": " The VkFormat of each of srcImage and dstImage must be compatible, as defined above" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkCmdCopyImage-srcImage-01546", + "text": " If srcImage is non-sparse then the image or disjoint plane to be copied must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-01547", + "text": " If dstImage is non-sparse then the image or disjoint plane that is the destination of the copy must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-01548", + "text": " If the VkFormat of each of srcImage and dstImage is not a multi-planar format, the VkFormat of each of srcImage and dstImage must be compatible, as defined above" + }, + { + "vuid": "VUID-vkCmdCopyImage-None-01549", + "text": " In a copy to or from a plane of a multi-planar image, the VkFormat of the image and plane must be compatible according to the description of compatible planes for the plane being copied" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-01551", + "text": " If neither srcImage nor dstImage has a multi-planar image format then for each element of pRegions, srcSubresource.aspectMask and dstSubresource.aspectMask must match" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-01552", + "text": " If srcImage has a VkFormat with two planes then for each element of pRegions, srcSubresource.aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-01553", + "text": " If srcImage has a VkFormat with three planes then for each element of pRegions, srcSubresource.aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-01554", + "text": " If dstImage has a VkFormat with two planes then for each element of pRegions, dstSubresource.aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-01555", + "text": " If dstImage has a VkFormat with three planes then for each element of pRegions, dstSubresource.aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-01556", + "text": " If srcImage has a multi-planar image format and the dstImage does not have a multi-planar image format, then for each element of pRegions, dstSubresource.aspectMask must be VK_IMAGE_ASPECT_COLOR_BIT" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImage-01557", + "text": " If dstImage has a multi-planar image format and the srcImage does not have a multi-planar image format, then for each element of pRegions, srcSubresource.aspectMask must be VK_IMAGE_ASPECT_COLOR_BIT" + } + ], + "!(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdCopyImage-srcImageLayout-00129", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImageLayout-00134", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdCopyImage-srcImageLayout-01917", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR" + }, + { + "vuid": "VUID-vkCmdCopyImage-dstImageLayout-01395", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR" + } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdCopyImage-dstImage-02542", + "text": " dstImage and srcImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT" + } + ], + "!(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-vkCmdCopyImage-srcImage-00139", + "text": " If either srcImage or dstImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, srcSubresource.baseArrayLayer and dstSubresource.baseArrayLayer must each be 0, and srcSubresource.layerCount and dstSubresource.layerCount must each be 1" + }, + { + "vuid": "VUID-vkCmdCopyImage-srcImage-01789", + "text": " If srcImage or dstImage is of type VK_IMAGE_TYPE_2D, then for each element of pRegions, extent.depth must be 1" + } + ] + }, + "VkImageCopy": { + "!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageCopy-aspectMask-00137", + "text": " The aspectMask member of srcSubresource and dstSubresource must match" + } + ], + "!(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkImageCopy-layerCount-00138", + "text": " The layerCount member of srcSubresource and dstSubresource must match" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkImageCopy-extent-00140", + "text": " The number of slices of the extent (for 3D) or layers of the srcSubresource (for non-3D) must match the number of slices of the extent (for 3D) or layers of the dstSubresource (for non-3D)" + } + ], + "core": [ + { + "vuid": "VUID-VkImageCopy-srcSubresource-parameter", + "text": " srcSubresource must be a valid VkImageSubresourceLayers structure" + }, + { + "vuid": "VUID-VkImageCopy-dstSubresource-parameter", + "text": " dstSubresource must be a valid VkImageSubresourceLayers structure" + } + ] + }, + "VkImageSubresourceLayers": { + "core": [ + { + "vuid": "VUID-VkImageSubresourceLayers-aspectMask-00167", + "text": " If aspectMask contains VK_IMAGE_ASPECT_COLOR_BIT, it must not contain either of VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT" + }, + { + "vuid": "VUID-VkImageSubresourceLayers-aspectMask-00168", + "text": " aspectMask must not contain VK_IMAGE_ASPECT_METADATA_BIT" + }, + { + "vuid": "VUID-VkImageSubresourceLayers-layerCount-01700", + "text": " layerCount must be greater than 0" + }, + { + "vuid": "VUID-VkImageSubresourceLayers-aspectMask-parameter", + "text": " aspectMask must be a valid combination of VkImageAspectFlagBits values" + }, + { + "vuid": "VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask", + "text": " aspectMask must not be 0" + } + ], + "(VK_EXT_image_drm_format_modifier)": [ + { + "vuid": "VUID-VkImageSubresourceLayers-aspectMask-02247", + "text": " aspectMask must not include VK_IMAGE_ASPECT_MEMORY_PLANE{ibit}BIT_EXT for any index i" + } + ] + }, + "vkCmdCopyImage2KHR": { + "(VK_KHR_copy_commands2)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdCopyImage2KHR-commandBuffer-01825", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, srcImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdCopyImage2KHR-commandBuffer-01826", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, dstImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdCopyImage2KHR-commandBuffer-01827", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, dstImage must not be an unprotected image" + } + ], + "(VK_KHR_copy_commands2)": [ + { + "vuid": "VUID-vkCmdCopyImage2KHR-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyImage2KHR-pCopyImageInfo-parameter", + "text": " pCopyImageInfo must be a valid pointer to a valid VkCopyImageInfo2KHR structure" + }, + { + "vuid": "VUID-vkCmdCopyImage2KHR-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdCopyImage2KHR-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdCopyImage2KHR-renderpass", + "text": " This command must only be called outside of a render pass instance" + } + ] + }, + "VkCopyImageInfo2KHR": { + "(VK_KHR_copy_commands2)": [ + { + "vuid": "VUID-VkCopyImageInfo2KHR-pRegions-00124", + "text": " The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-00126", + "text": " srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImageLayout-00128", + "text": " srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImage-00131", + "text": " dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImageLayout-00133", + "text": " dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-00136", + "text": " The sample count of srcImage and dstImage must match" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcSubresource-01696", + "text": " The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstSubresource-01697", + "text": " The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcSubresource-01698", + "text": " The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstSubresource-01699", + "text": " The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcOffset-01783", + "text": " The srcOffset and extent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstOffset-01784", + "text": " The dstOffset and extent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-aspectMask-00142", + "text": " For each element of pRegions, srcSubresource.aspectMask must specify aspects present in srcImage" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-aspectMask-00143", + "text": " For each element of pRegions, dstSubresource.aspectMask must specify aspects present in dstImage" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcOffset-00144", + "text": " For each element of pRegions, srcOffset.x and (extent.width + srcOffset.x) must both be greater than or equal to 0 and less than or equal to the width of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcOffset-00145", + "text": " For each element of pRegions, srcOffset.y and (extent.height + srcOffset.y) must both be greater than or equal to 0 and less than or equal to the height of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-00146", + "text": " If srcImage is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, srcOffset.y must be 0 and extent.height must be 1" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcOffset-00147", + "text": " For each element of pRegions, srcOffset.z and (extent.depth + srcOffset.z) must both be greater than or equal to 0 and less than or equal to the depth of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-01785", + "text": " If srcImage is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, srcOffset.z must be 0 and extent.depth must be 1" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImage-01786", + "text": " If dstImage is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, dstOffset.z must be 0 and extent.depth must be 1" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-01787", + "text": " If srcImage is of type VK_IMAGE_TYPE_2D, then for each element of pRegions, srcOffset.z must be 0" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImage-01788", + "text": " If dstImage is of type VK_IMAGE_TYPE_2D, then for each element of pRegions, dstOffset.z must be 0" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstOffset-00150", + "text": " For each element of pRegions, dstOffset.x and (extent.width + dstOffset.x) must both be greater than or equal to 0 and less than or equal to the width of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstOffset-00151", + "text": " For each element of pRegions, dstOffset.y and (extent.height + dstOffset.y) must both be greater than or equal to 0 and less than or equal to the height of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImage-00152", + "text": " If dstImage is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, dstOffset.y must be 0 and extent.height must be 1" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstOffset-00153", + "text": " For each element of pRegions, dstOffset.z and (extent.depth + dstOffset.z) must both be greater than or equal to 0 and less than or equal to the depth of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-01727", + "text": " If srcImage is a blocked image, then for each element of pRegions, all members of srcOffset must be a multiple of the corresponding dimensions of the compressed texel block" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-01728", + "text": " If srcImage is a blocked image, then for each element of pRegions, extent.width must be a multiple of the compressed texel block width or (extent.width + srcOffset.x) must equal the width of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-01729", + "text": " If srcImage is a blocked image, then for each element of pRegions, extent.height must be a multiple of the compressed texel block height or (extent.height + srcOffset.y) must equal the height of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-01730", + "text": " If srcImage is a blocked image, then for each element of pRegions, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + srcOffset.z) must equal the depth of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImage-01731", + "text": " If dstImage is a blocked image, then for each element of pRegions, all members of dstOffset must be a multiple of the corresponding dimensions of the compressed texel block" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImage-01732", + "text": " If dstImage is a blocked image, then for each element of pRegions, extent.width must be a multiple of the compressed texel block width or (extent.width + dstOffset.x) must equal the width of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImage-01733", + "text": " If dstImage is a blocked image, then for each element of pRegions, extent.height must be a multiple of the compressed texel block height or (extent.height + dstOffset.y) must equal the height of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImage-01734", + "text": " If dstImage is a blocked image, then for each element of pRegions, extent.depth must be a multiple of the compressed texel block depth or (extent.depth + dstOffset.z) must equal the depth of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-parameter", + "text": " srcImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImageLayout-parameter", + "text": " srcImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImage-parameter", + "text": " dstImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImageLayout-parameter", + "text": " dstImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-pRegions-parameter", + "text": " pRegions must be a valid pointer to an array of regionCount valid VkImageCopy2KHR structures" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-regionCount-arraylength", + "text": " regionCount must be greater than 0" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-commonparent", + "text": " Both of dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_KHR_copy_commands2)+(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-01995", + "text": " The format features of srcImage must contain VK_FORMAT_FEATURE_TRANSFER_SRC_BIT" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImage-01996", + "text": " The format features of dstImage must contain VK_FORMAT_FEATURE_TRANSFER_DST_BIT" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-04443", + "text": " If srcImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, srcSubresource.baseArrayLayer must be 0 and srcSubresource.layerCount must be 1" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImage-04444", + "text": " If dstImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, dstSubresource.baseArrayLayer must be 0 and dstSubresource.layerCount must be 1" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-01790", + "text": " If srcImage and dstImage are both of type VK_IMAGE_TYPE_2D, then for each element of pRegions, extent.depth must be 1" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-01791", + "text": " If srcImage is of type VK_IMAGE_TYPE_2D, and dstImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, extent.depth must equal srcSubresource.layerCount" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImage-01792", + "text": " If dstImage is of type VK_IMAGE_TYPE_2D, and srcImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, extent.depth must equal dstSubresource.layerCount" + } + ], + "(VK_KHR_copy_commands2)+!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-00127", + "text": " If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImage-00132", + "text": " If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-00135", + "text": " The VkFormat of each of srcImage and dstImage must be compatible, as defined above" + } + ], + "(VK_KHR_copy_commands2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-01546", + "text": " If srcImage is non-sparse then the image or disjoint plane to be copied must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImage-01547", + "text": " If dstImage is non-sparse then the image or disjoint plane that is the destination of the copy must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-01548", + "text": " If the VkFormat of each of srcImage and dstImage is not a multi-planar format, the VkFormat of each of srcImage and dstImage must be compatible, as defined above" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-None-01549", + "text": " In a copy to or from a plane of a multi-planar image, the VkFormat of the image and plane must be compatible according to the description of compatible planes for the plane being copied" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-01551", + "text": " If neither srcImage nor dstImage has a multi-planar image format then for each element of pRegions, srcSubresource.aspectMask and dstSubresource.aspectMask must match" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-01552", + "text": " If srcImage has a VkFormat with two planes then for each element of pRegions, srcSubresource.aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-01553", + "text": " If srcImage has a VkFormat with three planes then for each element of pRegions, srcSubresource.aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImage-01554", + "text": " If dstImage has a VkFormat with two planes then for each element of pRegions, dstSubresource.aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImage-01555", + "text": " If dstImage has a VkFormat with three planes then for each element of pRegions, dstSubresource.aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-01556", + "text": " If srcImage has a multi-planar image format and the dstImage does not have a multi-planar image format, then for each element of pRegions, dstSubresource.aspectMask must be VK_IMAGE_ASPECT_COLOR_BIT" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImage-01557", + "text": " If dstImage has a multi-planar image format and the srcImage does not have a multi-planar image format, then for each element of pRegions, srcSubresource.aspectMask must be VK_IMAGE_ASPECT_COLOR_BIT" + } + ], + "(VK_KHR_copy_commands2)+!(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImageLayout-00129", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImageLayout-00134", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_KHR_copy_commands2)+(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImageLayout-01917", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImageLayout-01395", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR" + } + ], + "(VK_KHR_copy_commands2)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkCopyImageInfo2KHR-dstImage-02542", + "text": " dstImage and srcImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT" + } + ], + "(VK_KHR_copy_commands2)+!(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-00139", + "text": " If either srcImage or dstImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, srcSubresource.baseArrayLayer and dstSubresource.baseArrayLayer must each be 0, and srcSubresource.layerCount and dstSubresource.layerCount must each be 1" + }, + { + "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-01789", + "text": " If srcImage or dstImage is of type VK_IMAGE_TYPE_2D, then for each element of pRegions, extent.depth must be 1" + } + ] + }, + "VkImageCopy2KHR": { + "(VK_KHR_copy_commands2)+!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkImageCopy2KHR-aspectMask-00137", + "text": " The aspectMask member of srcSubresource and dstSubresource must match" + } + ], + "(VK_KHR_copy_commands2)+!(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkImageCopy2KHR-layerCount-00138", + "text": " The layerCount member of srcSubresource and dstSubresource must match" + } + ], + "(VK_KHR_copy_commands2)+(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkImageCopy2KHR-extent-00140", + "text": " The number of slices of the extent (for 3D) or layers of the srcSubresource (for non-3D) must match the number of slices of the extent (for 3D) or layers of the dstSubresource (for non-3D)" + } + ], + "(VK_KHR_copy_commands2)": [ + { + "vuid": "VUID-VkImageCopy2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR" + }, + { + "vuid": "VUID-VkImageCopy2KHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkImageCopy2KHR-srcSubresource-parameter", + "text": " srcSubresource must be a valid VkImageSubresourceLayers structure" + }, + { + "vuid": "VUID-VkImageCopy2KHR-dstSubresource-parameter", + "text": " dstSubresource must be a valid VkImageSubresourceLayers structure" + } + ] + }, + "vkCmdCopyBufferToImage": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-01828", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, srcBuffer must not be a protected buffer" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-01829", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, dstImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-01830", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, dstImage must not be an unprotected image" + } + ], + "core": [ + { + "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-06217", + "text": " The image region specified by each element of pRegions must be contained within the specified imageSubresource of dstImage" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-00171", + "text": " srcBuffer must be large enough to contain all buffer locations that are accessed according to Buffer and Image Addressing, for each element of pRegions" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-00173", + "text": " The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-srcBuffer-00174", + "text": " srcBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-srcBuffer-00176", + "text": " If srcBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-00177", + "text": " dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-00178", + "text": " If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-00179", + "text": " dstImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-dstImageLayout-00180", + "text": " dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-imageSubresource-01701", + "text": " The imageSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-imageSubresource-01702", + "text": " The imageSubresource.baseArrayLayer + imageSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-imageOffset-01793", + "text": " The imageOffset and imageExtent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-04477", + "text": " If the queue family used to create the VkCommandPool which commandBuffer was allocated from does not support VK_QUEUE_GRAPHICS_BIT, for each element of pRegions, the aspectMask member of imageSubresource must not be VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-06218", + "text": " For each element of pRegions, imageOffset.x and (imageExtent.width + imageOffset.x) must both be greater than or equal to 0 and less than or equal to the width of the specified imageSubresource of dstImage" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-06219", + "text": " For each element of pRegions, imageOffset.y and (imageExtent.height + imageOffset.y) must both be greater than or equal to 0 and less than or equal to the height of the specified imageSubresource of dstImage" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-srcImage-00199", + "text": " If {imageparam} is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, imageOffset.y must be 0 and imageExtent.height must be 1" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-imageOffset-00200", + "text": " For each element of pRegions, imageOffset.z and (imageExtent.depth + imageOffset.z) must both be greater than or equal to 0 and less than or equal to the depth of the specified imageSubresource of {imageparam}" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-srcImage-00201", + "text": " If {imageparam} is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then for each element of pRegions, imageOffset.z must be 0 and imageExtent.depth must be 1" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-bufferRowLength-00203", + "text": " If {imageparam} is a blocked image, for each element of pRegions, bufferRowLength must be a multiple of the compressed texel block width" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-bufferImageHeight-00204", + "text": " If {imageparam} is a blocked image, for each element of pRegions, bufferImageHeight must be a multiple of the compressed texel block height" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-imageOffset-00205", + "text": " If {imageparam} is a blocked image, for each element of pRegions, all members of imageOffset must be a multiple of the corresponding dimensions of the compressed texel block" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-bufferOffset-00206", + "text": " If {imageparam} is a blocked image, for each element of pRegions, bufferOffset must be a multiple of the compressed texel block size in bytes" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-imageExtent-00207", + "text": " If {imageparam} is a blocked image, for each element of pRegions, imageExtent.width must be a multiple of the compressed texel block width or (imageExtent.width + imageOffset.x) must equal the width of the specified imageSubresource of {imageparam}" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-imageExtent-00208", + "text": " If {imageparam} is a blocked image, for each element of pRegions, imageExtent.height must be a multiple of the compressed texel block height or (imageExtent.height + imageOffset.y) must equal the height of the specified imageSubresource of {imageparam}" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-imageExtent-00209", + "text": " If {imageparam} is a blocked image, for each element of pRegions, imageExtent.depth must be a multiple of the compressed texel block depth or (imageExtent.depth + imageOffset.z) must equal the depth of the specified imageSubresource of {imageparam}" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-aspectMask-00211", + "text": " For each element of pRegions, imageSubresource.aspectMask must specify aspects present in {imageparam}" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-baseArrayLayer-00213", + "text": " If {imageparam} is of type VK_IMAGE_TYPE_3D, for each element of pRegions, imageSubresource.baseArrayLayer must be 0 and imageSubresource.layerCount must be 1" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-04725", + "text": " If {imageparam} is not a blocked image, for each element of pRegions, bufferRowLength multiplied by the texel block size of {imageparam} must be less than or equal to 231-1" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-04726", + "text": " If {imageparam} is a blocked image, for each element of pRegions, bufferRowLength divided by the compressed texel block width and then multiplied by the texel block size of {imageparam} must be less than or equal to 231-1" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-04052", + "text": " If the queue family used to create the VkCommandPool which commandBuffer was allocated from does not support VK_QUEUE_GRAPHICS_BIT or VK_QUEUE_COMPUTE_BIT, the bufferOffset member of any element of pRegions must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-srcImage-04053", + "text": " If {imageparam} has a depth/stencil format, the bufferOffset member of any element of pRegions must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-srcBuffer-parameter", + "text": " srcBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-parameter", + "text": " dstImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-dstImageLayout-parameter", + "text": " dstImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-parameter", + "text": " pRegions must be a valid pointer to an array of regionCount valid VkBufferImageCopy structures" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-regionCount-arraylength", + "text": " regionCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-commonparent", + "text": " Each of commandBuffer, dstImage, and srcBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-01997", + "text": " The format features of dstImage must contain VK_FORMAT_FEATURE_TRANSFER_DST_BIT" + } + ], + "!(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdCopyBufferToImage-dstImageLayout-00181", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdCopyBufferToImage-dstImageLayout-01396", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR" + } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-02543", + "text": " dstImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT" + } + ], + "!(VK_EXT_depth_range_unrestricted)": [ + { + "vuid": "VUID-vkCmdCopyBufferToImage-None-00214", + "text": " For each element of pRegions whose imageSubresource contains a depth aspect, the data in srcBuffer must be in the range [0,1]" + } + ], + "!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkCmdCopyBufferToImage-bufferOffset-00193", + "text": " If {imageparam} does not have a depth/stencil format, then for each element of pRegions, bufferOffset must be a multiple of the format’s texel block size" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkCmdCopyBufferToImage-bufferOffset-01558", + "text": " If {imageparam} does not have either a depth/stencil or a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the format’s texel block size" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-bufferOffset-01559", + "text": " If {imageparam} has a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the element size of the compatible format for the format and the aspectMask of the imageSubresource as defined in Compatible formats of planes of multi-planar formats" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage-aspectMask-01560", + "text": " If {imageparam} has a multi-planar format, then for each element of pRegions, imageSubresource.aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT (with VK_IMAGE_ASPECT_PLANE_2_BIT valid only for image formats with three planes)" + } + ] + }, + "vkCmdCopyImageToBuffer": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-01831", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, srcImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-01832", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, dstBuffer must not be a protected buffer" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-01833", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, dstBuffer must not be an unprotected buffer" + } + ], + "core": [ + { + "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-06220", + "text": " The image region specified by each element of pRegions must be contained within the specified imageSubresource of srcImage" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-00183", + "text": " dstBuffer must be large enough to contain all buffer locations that are accessed according to Buffer and Image Addressing, for each element of pRegions" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-00184", + "text": " The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-00186", + "text": " srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-00187", + "text": " If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-dstBuffer-00191", + "text": " dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-dstBuffer-00192", + "text": " If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-00188", + "text": " srcImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImageLayout-00189", + "text": " srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-imageSubresource-01703", + "text": " The imageSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-imageSubresource-01704", + "text": " The imageSubresource.baseArrayLayer + imageSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-imageOffset-01794", + "text": " The imageOffset and imageExtent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-06221", + "text": " For each element of pRegions, imageOffset.x and (imageExtent.width + imageOffset.x) must both be greater than or equal to 0 and less than or equal to the width of the specified imageSubresource of srcImage" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-06222", + "text": " For each element of pRegions, imageOffset.y and (imageExtent.height + imageOffset.y) must both be greater than or equal to 0 and less than or equal to the height of the specified imageSubresource of srcImage" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-00199", + "text": " If {imageparam} is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, imageOffset.y must be 0 and imageExtent.height must be 1" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-imageOffset-00200", + "text": " For each element of pRegions, imageOffset.z and (imageExtent.depth + imageOffset.z) must both be greater than or equal to 0 and less than or equal to the depth of the specified imageSubresource of {imageparam}" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-00201", + "text": " If {imageparam} is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then for each element of pRegions, imageOffset.z must be 0 and imageExtent.depth must be 1" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-bufferRowLength-00203", + "text": " If {imageparam} is a blocked image, for each element of pRegions, bufferRowLength must be a multiple of the compressed texel block width" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-bufferImageHeight-00204", + "text": " If {imageparam} is a blocked image, for each element of pRegions, bufferImageHeight must be a multiple of the compressed texel block height" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-imageOffset-00205", + "text": " If {imageparam} is a blocked image, for each element of pRegions, all members of imageOffset must be a multiple of the corresponding dimensions of the compressed texel block" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-bufferOffset-00206", + "text": " If {imageparam} is a blocked image, for each element of pRegions, bufferOffset must be a multiple of the compressed texel block size in bytes" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-imageExtent-00207", + "text": " If {imageparam} is a blocked image, for each element of pRegions, imageExtent.width must be a multiple of the compressed texel block width or (imageExtent.width + imageOffset.x) must equal the width of the specified imageSubresource of {imageparam}" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-imageExtent-00208", + "text": " If {imageparam} is a blocked image, for each element of pRegions, imageExtent.height must be a multiple of the compressed texel block height or (imageExtent.height + imageOffset.y) must equal the height of the specified imageSubresource of {imageparam}" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-imageExtent-00209", + "text": " If {imageparam} is a blocked image, for each element of pRegions, imageExtent.depth must be a multiple of the compressed texel block depth or (imageExtent.depth + imageOffset.z) must equal the depth of the specified imageSubresource of {imageparam}" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-aspectMask-00211", + "text": " For each element of pRegions, imageSubresource.aspectMask must specify aspects present in {imageparam}" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-baseArrayLayer-00213", + "text": " If {imageparam} is of type VK_IMAGE_TYPE_3D, for each element of pRegions, imageSubresource.baseArrayLayer must be 0 and imageSubresource.layerCount must be 1" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-04725", + "text": " If {imageparam} is not a blocked image, for each element of pRegions, bufferRowLength multiplied by the texel block size of {imageparam} must be less than or equal to 231-1" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-04726", + "text": " If {imageparam} is a blocked image, for each element of pRegions, bufferRowLength divided by the compressed texel block width and then multiplied by the texel block size of {imageparam} must be less than or equal to 231-1" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-04052", + "text": " If the queue family used to create the VkCommandPool which commandBuffer was allocated from does not support VK_QUEUE_GRAPHICS_BIT or VK_QUEUE_COMPUTE_BIT, the bufferOffset member of any element of pRegions must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-04053", + "text": " If {imageparam} has a depth/stencil format, the bufferOffset member of any element of pRegions must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-parameter", + "text": " srcImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImageLayout-parameter", + "text": " srcImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-dstBuffer-parameter", + "text": " dstBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-parameter", + "text": " pRegions must be a valid pointer to an array of regionCount valid VkBufferImageCopy structures" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-regionCount-arraylength", + "text": " regionCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-commonparent", + "text": " Each of commandBuffer, dstBuffer, and srcImage must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-01998", + "text": " The format features of srcImage must contain VK_FORMAT_FEATURE_TRANSFER_SRC_BIT" + } + ], + "!(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImageLayout-00190", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImageLayout-01397", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR" + } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-02544", + "text": " srcImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT" + } + ], + "!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkCmdCopyImageToBuffer-bufferOffset-00193", + "text": " If {imageparam} does not have a depth/stencil format, then for each element of pRegions, bufferOffset must be a multiple of the format’s texel block size" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkCmdCopyImageToBuffer-bufferOffset-01558", + "text": " If {imageparam} does not have either a depth/stencil or a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the format’s texel block size" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-bufferOffset-01559", + "text": " If {imageparam} has a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the element size of the compatible format for the format and the aspectMask of the imageSubresource as defined in Compatible formats of planes of multi-planar formats" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer-aspectMask-01560", + "text": " If {imageparam} has a multi-planar format, then for each element of pRegions, imageSubresource.aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT (with VK_IMAGE_ASPECT_PLANE_2_BIT valid only for image formats with three planes)" + } + ] + }, + "VkBufferImageCopy": { + "core": [ + { + "vuid": "VUID-VkBufferImageCopy-bufferRowLength-00195", + "text": " bufferRowLength must be 0, or greater than or equal to the width member of imageExtent" + }, + { + "vuid": "VUID-VkBufferImageCopy-bufferImageHeight-00196", + "text": " bufferImageHeight must be 0, or greater than or equal to the height member of imageExtent" + }, + { + "vuid": "VUID-VkBufferImageCopy-aspectMask-00212", + "text": " The aspectMask member of imageSubresource must only have a single bit set" + }, + { + "vuid": "VUID-VkBufferImageCopy-imageSubresource-parameter", + "text": " imageSubresource must be a valid VkImageSubresourceLayers structure" + } + ] + }, + "vkCmdCopyBufferToImage2KHR": { + "(VK_KHR_copy_commands2)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdCopyBufferToImage2KHR-commandBuffer-01828", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, srcBuffer must not be a protected buffer" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage2KHR-commandBuffer-01829", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, dstImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage2KHR-commandBuffer-01830", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, dstImage must not be an unprotected image" + } + ], + "(VK_KHR_copy_commands2)": [ + { + "vuid": "VUID-vkCmdCopyBufferToImage2KHR-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage2KHR-pCopyBufferToImageInfo-parameter", + "text": " pCopyBufferToImageInfo must be a valid pointer to a valid VkCopyBufferToImageInfo2KHR structure" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage2KHR-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage2KHR-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdCopyBufferToImage2KHR-renderpass", + "text": " This command must only be called outside of a render pass instance" + } + ] + }, + "VkCopyBufferToImageInfo2KHR": { + "(VK_KHR_copy_commands2)+!(VK_QCOM_rotated_copy_commands)": [ + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-pRegions-00172", + "text": " The image region specified by each element of pRegions must be contained within the specified imageSubresource of dstImage" + } + ], + "(VK_KHR_copy_commands2)+(VK_QCOM_rotated_copy_commands)": [ + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-pRegions-04565", + "text": " If the image region specified by each element of pRegions does not contain VkCopyCommandTransformInfoQCOM in its pNext chain, it must be a region that is contained within the specified imageSubresource of dstImage" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-pRegions-04554", + "text": " If the image region specified by each element of pRegions contains VkCopyCommandTransformInfoQCOM in its pNext chain, the rotated destination region as described in Buffer and Image Addressing with Rotation must be contained within dstImage" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-pRegions-04555", + "text": " If any element of pRegions contains VkCopyCommandTransformInfoQCOM in its pNext chain, then dstImage must not be a blocked image" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-pRegions-06203", + "text": " If any element of pRegions contains VkCopyCommandTransformInfoQCOM in its pNext chain, then dstImage must be of type VK_IMAGE_TYPE_2D" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-pRegions-06204", + "text": " If any element of pRegions contains VkCopyCommandTransformInfoQCOM in its pNext chain, then dstImage must not have a multi-planar format" + } + ], + "(VK_KHR_copy_commands2)": [ + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-pRegions-00171", + "text": " srcBuffer must be large enough to contain all buffer locations that are accessed according to Buffer and Image Addressing, for each element of pRegions" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-pRegions-00173", + "text": " The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-srcBuffer-00174", + "text": " srcBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-srcBuffer-00176", + "text": " If srcBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-dstImage-00177", + "text": " dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-dstImage-00178", + "text": " If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-dstImage-00179", + "text": " dstImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-dstImageLayout-00180", + "text": " dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-imageSubresource-01701", + "text": " The imageSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-imageSubresource-01702", + "text": " The imageSubresource.baseArrayLayer + imageSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-imageOffset-01793", + "text": " The imageOffset and imageExtent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-commandBuffer-04477", + "text": " If the queue family used to create the VkCommandPool which commandBuffer was allocated from does not support VK_QUEUE_GRAPHICS_BIT, for each element of pRegions, the aspectMask member of imageSubresource must not be VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-pRegions-06223", + "text": " For each element of pRegions not containing VkCopyCommandTransformInfoQCOM in its pNext chain, imageOffset.x and (imageExtent.width + imageOffset.x) must both be greater than or equal to 0 and less than or equal to the width of the specified imageSubresource of dstImage" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-pRegions-06224", + "text": " For each element of pRegions not containing VkCopyCommandTransformInfoQCOM in its pNext chain, imageOffset.y and (imageExtent.height + imageOffset.y) must both be greater than or equal to 0 and less than or equal to the height of the specified imageSubresource of dstImage" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-srcImage-00199", + "text": " If {imageparam} is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, imageOffset.y must be 0 and imageExtent.height must be 1" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-imageOffset-00200", + "text": " For each element of pRegions, imageOffset.z and (imageExtent.depth + imageOffset.z) must both be greater than or equal to 0 and less than or equal to the depth of the specified imageSubresource of {imageparam}" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-srcImage-00201", + "text": " If {imageparam} is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then for each element of pRegions, imageOffset.z must be 0 and imageExtent.depth must be 1" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-bufferRowLength-00203", + "text": " If {imageparam} is a blocked image, for each element of pRegions, bufferRowLength must be a multiple of the compressed texel block width" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-bufferImageHeight-00204", + "text": " If {imageparam} is a blocked image, for each element of pRegions, bufferImageHeight must be a multiple of the compressed texel block height" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-imageOffset-00205", + "text": " If {imageparam} is a blocked image, for each element of pRegions, all members of imageOffset must be a multiple of the corresponding dimensions of the compressed texel block" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-bufferOffset-00206", + "text": " If {imageparam} is a blocked image, for each element of pRegions, bufferOffset must be a multiple of the compressed texel block size in bytes" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-imageExtent-00207", + "text": " If {imageparam} is a blocked image, for each element of pRegions, imageExtent.width must be a multiple of the compressed texel block width or (imageExtent.width + imageOffset.x) must equal the width of the specified imageSubresource of {imageparam}" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-imageExtent-00208", + "text": " If {imageparam} is a blocked image, for each element of pRegions, imageExtent.height must be a multiple of the compressed texel block height or (imageExtent.height + imageOffset.y) must equal the height of the specified imageSubresource of {imageparam}" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-imageExtent-00209", + "text": " If {imageparam} is a blocked image, for each element of pRegions, imageExtent.depth must be a multiple of the compressed texel block depth or (imageExtent.depth + imageOffset.z) must equal the depth of the specified imageSubresource of {imageparam}" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-aspectMask-00211", + "text": " For each element of pRegions, imageSubresource.aspectMask must specify aspects present in {imageparam}" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-baseArrayLayer-00213", + "text": " If {imageparam} is of type VK_IMAGE_TYPE_3D, for each element of pRegions, imageSubresource.baseArrayLayer must be 0 and imageSubresource.layerCount must be 1" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-pRegions-04725", + "text": " If {imageparam} is not a blocked image, for each element of pRegions, bufferRowLength multiplied by the texel block size of {imageparam} must be less than or equal to 231-1" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-pRegions-04726", + "text": " If {imageparam} is a blocked image, for each element of pRegions, bufferRowLength divided by the compressed texel block width and then multiplied by the texel block size of {imageparam} must be less than or equal to 231-1" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-commandBuffer-04052", + "text": " If the queue family used to create the VkCommandPool which commandBuffer was allocated from does not support VK_QUEUE_GRAPHICS_BIT or VK_QUEUE_COMPUTE_BIT, the bufferOffset member of any element of pRegions must be a multiple of 4" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-srcImage-04053", + "text": " If {imageparam} has a depth/stencil format, the bufferOffset member of any element of pRegions must be a multiple of 4" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-srcBuffer-parameter", + "text": " srcBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-dstImage-parameter", + "text": " dstImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-dstImageLayout-parameter", + "text": " dstImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-pRegions-parameter", + "text": " pRegions must be a valid pointer to an array of regionCount valid VkBufferImageCopy2KHR structures" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-regionCount-arraylength", + "text": " regionCount must be greater than 0" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-commonparent", + "text": " Both of dstImage, and srcBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_KHR_copy_commands2)+(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-dstImage-01997", + "text": " The format features of dstImage must contain VK_FORMAT_FEATURE_TRANSFER_DST_BIT" + } + ], + "(VK_KHR_copy_commands2)+!(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-dstImageLayout-00181", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_KHR_copy_commands2)+(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-dstImageLayout-01396", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR" + } + ], + "(VK_KHR_copy_commands2)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-dstImage-02543", + "text": " dstImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT" + } + ], + "(VK_KHR_copy_commands2)+!(VK_EXT_depth_range_unrestricted)": [ + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-None-00214", + "text": " For each element of pRegions whose imageSubresource contains a depth aspect, the data in srcBuffer must be in the range [0,1]" + } + ], + "(VK_KHR_copy_commands2)+!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-bufferOffset-00193", + "text": " If {imageparam} does not have a depth/stencil format, then for each element of pRegions, bufferOffset must be a multiple of the format’s texel block size" + } + ], + "(VK_KHR_copy_commands2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-bufferOffset-01558", + "text": " If {imageparam} does not have either a depth/stencil or a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the format’s texel block size" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-bufferOffset-01559", + "text": " If {imageparam} has a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the element size of the compatible format for the format and the aspectMask of the imageSubresource as defined in Compatible formats of planes of multi-planar formats" + }, + { + "vuid": "VUID-VkCopyBufferToImageInfo2KHR-aspectMask-01560", + "text": " If {imageparam} has a multi-planar format, then for each element of pRegions, imageSubresource.aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT (with VK_IMAGE_ASPECT_PLANE_2_BIT valid only for image formats with three planes)" + } + ] + }, + "vkCmdCopyImageToBuffer2KHR": { + "(VK_KHR_copy_commands2)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdCopyImageToBuffer2KHR-commandBuffer-01831", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, srcImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer2KHR-commandBuffer-01832", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, dstBuffer must not be a protected buffer" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer2KHR-commandBuffer-01833", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, dstBuffer must not be an unprotected buffer" + } + ], + "(VK_KHR_copy_commands2)": [ + { + "vuid": "VUID-vkCmdCopyImageToBuffer2KHR-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer2KHR-pCopyImageToBufferInfo-parameter", + "text": " pCopyImageToBufferInfo must be a valid pointer to a valid VkCopyImageToBufferInfo2KHR structure" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer2KHR-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer2KHR-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdCopyImageToBuffer2KHR-renderpass", + "text": " This command must only be called outside of a render pass instance" + } + ] + }, + "VkCopyImageToBufferInfo2KHR": { + "(VK_KHR_copy_commands2)+!(VK_QCOM_rotated_copy_commands)": [ + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-pRegions-00182", + "text": " The image region specified by each element of pRegions must be contained within the specified imageSubresource of srcImage" + } + ], + "(VK_KHR_copy_commands2)+(VK_QCOM_rotated_copy_commands)": [ + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-pRegions-04566", + "text": " If the image region specified by each element of pRegions does not contain VkCopyCommandTransformInfoQCOM in its pNext chain, it must be contained within the specified imageSubresource of srcImage" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-pRegions-04557", + "text": " If the image region specified by each element of pRegions contains VkCopyCommandTransformInfoQCOM in its pNext chain, the rotated source region as described in Buffer and Image Addressing with Rotation must be contained within srcImage" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-pRegions-04558", + "text": " If any element of pRegions contains VkCopyCommandTransformInfoQCOM in its pNext chain, then srcImage must not be a blocked image" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-pRegions-06205", + "text": " If any element of pRegions contains VkCopyCommandTransformInfoQCOM in its pNext chain, then srcImage must be of type VK_IMAGE_TYPE_2D" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-pRegions-06206", + "text": " If any element of pRegions contains VkCopyCommandTransformInfoQCOM in its pNext chain, then srcImage must not have a multi-planar format" + } + ], + "(VK_KHR_copy_commands2)": [ + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-pRegions-00183", + "text": " dstBuffer must be large enough to contain all buffer locations that are accessed according to Buffer and Image Addressing, for each element of pRegions" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-pRegions-00184", + "text": " The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-srcImage-00186", + "text": " srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-srcImage-00187", + "text": " If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-dstBuffer-00191", + "text": " dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-dstBuffer-00192", + "text": " If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-srcImage-00188", + "text": " srcImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-srcImageLayout-00189", + "text": " srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-imageSubresource-01703", + "text": " The imageSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-imageSubresource-01704", + "text": " The imageSubresource.baseArrayLayer + imageSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-imageOffset-01794", + "text": " The imageOffset and imageExtent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer’s command pool’s queue family, as described in VkQueueFamilyProperties" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-imageOffset-00197", + "text": " For each element of pRegions not containing VkCopyCommandTransformInfoQCOM in its pNext chain, imageOffset.x and (imageExtent.width + imageOffset.x) must both be greater than or equal to 0 and less than or equal to the width of the specified imageSubresource of srcImage" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-imageOffset-00198", + "text": " For each element of pRegions not containing VkCopyCommandTransformInfoQCOM in its pNext chain, imageOffset.y and (imageExtent.height + imageOffset.y) must both be greater than or equal to 0 and less than or equal to the height of the specified imageSubresource of srcImage" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-srcImage-00199", + "text": " If {imageparam} is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, imageOffset.y must be 0 and imageExtent.height must be 1" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-imageOffset-00200", + "text": " For each element of pRegions, imageOffset.z and (imageExtent.depth + imageOffset.z) must both be greater than or equal to 0 and less than or equal to the depth of the specified imageSubresource of {imageparam}" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-srcImage-00201", + "text": " If {imageparam} is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then for each element of pRegions, imageOffset.z must be 0 and imageExtent.depth must be 1" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-bufferRowLength-00203", + "text": " If {imageparam} is a blocked image, for each element of pRegions, bufferRowLength must be a multiple of the compressed texel block width" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-bufferImageHeight-00204", + "text": " If {imageparam} is a blocked image, for each element of pRegions, bufferImageHeight must be a multiple of the compressed texel block height" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-imageOffset-00205", + "text": " If {imageparam} is a blocked image, for each element of pRegions, all members of imageOffset must be a multiple of the corresponding dimensions of the compressed texel block" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-bufferOffset-00206", + "text": " If {imageparam} is a blocked image, for each element of pRegions, bufferOffset must be a multiple of the compressed texel block size in bytes" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-imageExtent-00207", + "text": " If {imageparam} is a blocked image, for each element of pRegions, imageExtent.width must be a multiple of the compressed texel block width or (imageExtent.width + imageOffset.x) must equal the width of the specified imageSubresource of {imageparam}" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-imageExtent-00208", + "text": " If {imageparam} is a blocked image, for each element of pRegions, imageExtent.height must be a multiple of the compressed texel block height or (imageExtent.height + imageOffset.y) must equal the height of the specified imageSubresource of {imageparam}" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-imageExtent-00209", + "text": " If {imageparam} is a blocked image, for each element of pRegions, imageExtent.depth must be a multiple of the compressed texel block depth or (imageExtent.depth + imageOffset.z) must equal the depth of the specified imageSubresource of {imageparam}" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-aspectMask-00211", + "text": " For each element of pRegions, imageSubresource.aspectMask must specify aspects present in {imageparam}" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-baseArrayLayer-00213", + "text": " If {imageparam} is of type VK_IMAGE_TYPE_3D, for each element of pRegions, imageSubresource.baseArrayLayer must be 0 and imageSubresource.layerCount must be 1" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-pRegions-04725", + "text": " If {imageparam} is not a blocked image, for each element of pRegions, bufferRowLength multiplied by the texel block size of {imageparam} must be less than or equal to 231-1" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-pRegions-04726", + "text": " If {imageparam} is a blocked image, for each element of pRegions, bufferRowLength divided by the compressed texel block width and then multiplied by the texel block size of {imageparam} must be less than or equal to 231-1" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-commandBuffer-04052", + "text": " If the queue family used to create the VkCommandPool which commandBuffer was allocated from does not support VK_QUEUE_GRAPHICS_BIT or VK_QUEUE_COMPUTE_BIT, the bufferOffset member of any element of pRegions must be a multiple of 4" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-srcImage-04053", + "text": " If {imageparam} has a depth/stencil format, the bufferOffset member of any element of pRegions must be a multiple of 4" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-srcImage-parameter", + "text": " srcImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-srcImageLayout-parameter", + "text": " srcImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-dstBuffer-parameter", + "text": " dstBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-pRegions-parameter", + "text": " pRegions must be a valid pointer to an array of regionCount valid VkBufferImageCopy2KHR structures" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-regionCount-arraylength", + "text": " regionCount must be greater than 0" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-commonparent", + "text": " Both of dstBuffer, and srcImage must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_KHR_copy_commands2)+(VK_VERSION_1_1,VK_KHR_maintenance1)": [ + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-srcImage-01998", + "text": " The format features of srcImage must contain VK_FORMAT_FEATURE_TRANSFER_SRC_BIT" + } + ], + "(VK_KHR_copy_commands2)+!(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-srcImageLayout-00190", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_KHR_copy_commands2)+(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-srcImageLayout-01397", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR" + } + ], + "(VK_KHR_copy_commands2)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-srcImage-02544", + "text": " srcImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT" + } + ], + "(VK_KHR_copy_commands2)+!(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-bufferOffset-00193", + "text": " If {imageparam} does not have a depth/stencil format, then for each element of pRegions, bufferOffset must be a multiple of the format’s texel block size" + } + ], + "(VK_KHR_copy_commands2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-bufferOffset-01558", + "text": " If {imageparam} does not have either a depth/stencil or a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the format’s texel block size" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-bufferOffset-01559", + "text": " If {imageparam} has a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the element size of the compatible format for the format and the aspectMask of the imageSubresource as defined in Compatible formats of planes of multi-planar formats" + }, + { + "vuid": "VUID-VkCopyImageToBufferInfo2KHR-aspectMask-01560", + "text": " If {imageparam} has a multi-planar format, then for each element of pRegions, imageSubresource.aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT (with VK_IMAGE_ASPECT_PLANE_2_BIT valid only for image formats with three planes)" + } + ] + }, + "VkBufferImageCopy2KHR": { + "(VK_KHR_copy_commands2)": [ + { + "vuid": "VUID-VkBufferImageCopy2KHR-bufferRowLength-00195", + "text": " bufferRowLength must be 0, or greater than or equal to the width member of imageExtent" + }, + { + "vuid": "VUID-VkBufferImageCopy2KHR-bufferImageHeight-00196", + "text": " bufferImageHeight must be 0, or greater than or equal to the height member of imageExtent" + }, + { + "vuid": "VUID-VkBufferImageCopy2KHR-aspectMask-00212", + "text": " The aspectMask member of imageSubresource must only have a single bit set" + }, + { + "vuid": "VUID-VkBufferImageCopy2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR" + }, + { + "vuid": "VUID-VkBufferImageCopy2KHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkBufferImageCopy2KHR-imageSubresource-parameter", + "text": " imageSubresource must be a valid VkImageSubresourceLayers structure" + } + ] + }, + "VkCopyCommandTransformInfoQCOM": { + "(VK_QCOM_rotated_copy_commands)": [ + { + "vuid": "VUID-VkCopyCommandTransformInfoQCOM-transform-04560", + "text": " transform must be VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR, VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR, or VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR" + } + ] + }, + "vkCmdBlitImage": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdBlitImage-commandBuffer-01834", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, srcImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdBlitImage-commandBuffer-01835", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, dstImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdBlitImage-commandBuffer-01836", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, dstImage must not be an unprotected image" + } + ], + "core": [ + { + "vuid": "VUID-vkCmdBlitImage-pRegions-00215", + "text": " The source region specified by each element of pRegions must be a region that is contained within srcImage" + }, + { + "vuid": "VUID-vkCmdBlitImage-pRegions-00216", + "text": " The destination region specified by each element of pRegions must be a region that is contained within dstImage" + }, + { + "vuid": "VUID-vkCmdBlitImage-pRegions-00217", + "text": " The union of all destination regions, specified by the elements of pRegions, must not overlap in memory with any texel that may be sampled during the blit operation" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImage-01999", + "text": " The format features of srcImage must contain VK_FORMAT_FEATURE_BLIT_SRC_BIT" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImage-00219", + "text": " srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImage-00220", + "text": " If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImageLayout-00221", + "text": " srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImage-02000", + "text": " The format features of dstImage must contain VK_FORMAT_FEATURE_BLIT_DST_BIT" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImage-00224", + "text": " dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImage-00225", + "text": " If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImageLayout-00226", + "text": " dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImage-00229", + "text": " If either of srcImage or dstImage was created with a signed integer VkFormat, the other must also have been created with a signed integer VkFormat" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImage-00230", + "text": " If either of srcImage or dstImage was created with an unsigned integer VkFormat, the other must also have been created with an unsigned integer VkFormat" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImage-00231", + "text": " If either of srcImage or dstImage was created with a depth/stencil format, the other must have exactly the same format" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImage-00232", + "text": " If srcImage was created with a depth/stencil format, filter must be VK_FILTER_NEAREST" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImage-00233", + "text": " srcImage must have been created with a samples value of VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImage-00234", + "text": " dstImage must have been created with a samples value of VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-vkCmdBlitImage-filter-02001", + "text": " If filter is VK_FILTER_LINEAR, then the format features of srcImage must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcSubresource-01705", + "text": " The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstSubresource-01706", + "text": " The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcSubresource-01707", + "text": " The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstSubresource-01708", + "text": " The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImage-00240", + "text": " If either srcImage or dstImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, srcSubresource.baseArrayLayer and dstSubresource.baseArrayLayer must each be 0, and srcSubresource.layerCount and dstSubresource.layerCount must each be 1" + }, + { + "vuid": "VUID-vkCmdBlitImage-aspectMask-00241", + "text": " For each element of pRegions, srcSubresource.aspectMask must specify aspects present in srcImage" + }, + { + "vuid": "VUID-vkCmdBlitImage-aspectMask-00242", + "text": " For each element of pRegions, dstSubresource.aspectMask must specify aspects present in dstImage" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcOffset-00243", + "text": " For each element of pRegions, srcOffsets[0].x and srcOffsets[1].x must both be greater than or equal to 0 and less than or equal to the width of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcOffset-00244", + "text": " For each element of pRegions, srcOffsets[0].y and srcOffsets[1].y must both be greater than or equal to 0 and less than or equal to the height of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImage-00245", + "text": " If srcImage is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, srcOffsets[0].y must be 0 and srcOffsets[1].y must be 1" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcOffset-00246", + "text": " For each element of pRegions, srcOffsets[0].z and srcOffsets[1].z must both be greater than or equal to 0 and less than or equal to the depth of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImage-00247", + "text": " If srcImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then for each element of pRegions, srcOffsets[0].z must be 0 and srcOffsets[1].z must be 1" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstOffset-00248", + "text": " For each element of pRegions, dstOffsets[0].x and dstOffsets[1].x must both be greater than or equal to 0 and less than or equal to the width of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstOffset-00249", + "text": " For each element of pRegions, dstOffsets[0].y and dstOffsets[1].y must both be greater than or equal to 0 and less than or equal to the height of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImage-00250", + "text": " If dstImage is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, dstOffsets[0].y must be 0 and dstOffsets[1].y must be 1" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstOffset-00251", + "text": " For each element of pRegions, dstOffsets[0].z and dstOffsets[1].z must both be greater than or equal to 0 and less than or equal to the depth of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImage-00252", + "text": " If dstImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then for each element of pRegions, dstOffsets[0].z must be 0 and dstOffsets[1].z must be 1" + }, + { + "vuid": "VUID-vkCmdBlitImage-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImage-parameter", + "text": " srcImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkCmdBlitImage-srcImageLayout-parameter", + "text": " srcImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImage-parameter", + "text": " dstImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImageLayout-parameter", + "text": " dstImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-vkCmdBlitImage-pRegions-parameter", + "text": " pRegions must be a valid pointer to an array of regionCount valid VkImageBlit structures" + }, + { + "vuid": "VUID-vkCmdBlitImage-filter-parameter", + "text": " filter must be a valid VkFilter value" + }, + { + "vuid": "VUID-vkCmdBlitImage-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdBlitImage-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBlitImage-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdBlitImage-regionCount-arraylength", + "text": " regionCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdBlitImage-commonparent", + "text": " Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-vkCmdBlitImage-srcImage-06421", + "text": " srcImage must not use a format that requires a sampler Y’CBCR conversion" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImage-06422", + "text": " dstImage must not use a format that requires a sampler Y’CBCR conversion" + } + ], + "!(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdBlitImage-srcImageLayout-00222", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImageLayout-00227", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdBlitImage-srcImageLayout-01398", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-vkCmdBlitImage-dstImageLayout-01399", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdBlitImage-filter-02002", + "text": " If filter is VK_FILTER_CUBIC_EXT, then the format features of srcImage must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdBlitImage-filter-00237", + "text": " If filter is VK_FILTER_CUBIC_EXT, srcImage must be of type VK_IMAGE_TYPE_2D" + } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdBlitImage-dstImage-02545", + "text": " dstImage and srcImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT" + } + ] + }, + "VkImageBlit": { + "core": [ + { + "vuid": "VUID-VkImageBlit-aspectMask-00238", + "text": " The aspectMask member of srcSubresource and dstSubresource must match" + }, + { + "vuid": "VUID-VkImageBlit-layerCount-00239", + "text": " The layerCount member of srcSubresource and dstSubresource must match" + }, + { + "vuid": "VUID-VkImageBlit-srcSubresource-parameter", + "text": " srcSubresource must be a valid VkImageSubresourceLayers structure" + }, + { + "vuid": "VUID-VkImageBlit-dstSubresource-parameter", + "text": " dstSubresource must be a valid VkImageSubresourceLayers structure" + } + ] + }, + "vkCmdBlitImage2KHR": { + "(VK_KHR_copy_commands2)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdBlitImage2KHR-commandBuffer-01834", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, srcImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdBlitImage2KHR-commandBuffer-01835", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, dstImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdBlitImage2KHR-commandBuffer-01836", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, dstImage must not be an unprotected image" + } + ], + "(VK_KHR_copy_commands2)": [ + { + "vuid": "VUID-vkCmdBlitImage2KHR-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdBlitImage2KHR-pBlitImageInfo-parameter", + "text": " pBlitImageInfo must be a valid pointer to a valid VkBlitImageInfo2KHR structure" + }, + { + "vuid": "VUID-vkCmdBlitImage2KHR-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdBlitImage2KHR-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBlitImage2KHR-renderpass", + "text": " This command must only be called outside of a render pass instance" + } + ] + }, + "VkBlitImageInfo2KHR": { + "(VK_KHR_copy_commands2)": [ + { + "vuid": "VUID-VkBlitImageInfo2KHR-pRegions-00215", + "text": " The source region specified by each element of pRegions must be a region that is contained within srcImage" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-pRegions-00216", + "text": " The destination region specified by each element of pRegions must be a region that is contained within dstImage" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-pRegions-00217", + "text": " The union of all destination regions, specified by the elements of pRegions, must not overlap in memory with any texel that may be sampled during the blit operation" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcImage-01999", + "text": " The format features of srcImage must contain VK_FORMAT_FEATURE_BLIT_SRC_BIT" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcImage-00219", + "text": " srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcImage-00220", + "text": " If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcImageLayout-00221", + "text": " srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-dstImage-02000", + "text": " The format features of dstImage must contain VK_FORMAT_FEATURE_BLIT_DST_BIT" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-dstImage-00224", + "text": " dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-dstImage-00225", + "text": " If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-dstImageLayout-00226", + "text": " dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcImage-00229", + "text": " If either of srcImage or dstImage was created with a signed integer VkFormat, the other must also have been created with a signed integer VkFormat" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcImage-00230", + "text": " If either of srcImage or dstImage was created with an unsigned integer VkFormat, the other must also have been created with an unsigned integer VkFormat" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcImage-00231", + "text": " If either of srcImage or dstImage was created with a depth/stencil format, the other must have exactly the same format" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcImage-00232", + "text": " If srcImage was created with a depth/stencil format, filter must be VK_FILTER_NEAREST" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcImage-00233", + "text": " srcImage must have been created with a samples value of VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-dstImage-00234", + "text": " dstImage must have been created with a samples value of VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-filter-02001", + "text": " If filter is VK_FILTER_LINEAR, then the format features of srcImage must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcSubresource-01705", + "text": " The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-dstSubresource-01706", + "text": " The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcSubresource-01707", + "text": " The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-dstSubresource-01708", + "text": " The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcImage-00240", + "text": " If either srcImage or dstImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, srcSubresource.baseArrayLayer and dstSubresource.baseArrayLayer must each be 0, and srcSubresource.layerCount and dstSubresource.layerCount must each be 1" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-aspectMask-00241", + "text": " For each element of pRegions, srcSubresource.aspectMask must specify aspects present in srcImage" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-aspectMask-00242", + "text": " For each element of pRegions, dstSubresource.aspectMask must specify aspects present in dstImage" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcOffset-00243", + "text": " For each element of pRegions, srcOffsets[0].x and srcOffsets[1].x must both be greater than or equal to 0 and less than or equal to the width of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcOffset-00244", + "text": " For each element of pRegions, srcOffsets[0].y and srcOffsets[1].y must both be greater than or equal to 0 and less than or equal to the height of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcImage-00245", + "text": " If srcImage is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, srcOffsets[0].y must be 0 and srcOffsets[1].y must be 1" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcOffset-00246", + "text": " For each element of pRegions, srcOffsets[0].z and srcOffsets[1].z must both be greater than or equal to 0 and less than or equal to the depth of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcImage-00247", + "text": " If srcImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then for each element of pRegions, srcOffsets[0].z must be 0 and srcOffsets[1].z must be 1" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-dstOffset-00248", + "text": " For each element of pRegions, dstOffsets[0].x and dstOffsets[1].x must both be greater than or equal to 0 and less than or equal to the width of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-dstOffset-00249", + "text": " For each element of pRegions, dstOffsets[0].y and dstOffsets[1].y must both be greater than or equal to 0 and less than or equal to the height of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-dstImage-00250", + "text": " If dstImage is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, dstOffsets[0].y must be 0 and dstOffsets[1].y must be 1" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-dstOffset-00251", + "text": " For each element of pRegions, dstOffsets[0].z and dstOffsets[1].z must both be greater than or equal to 0 and less than or equal to the depth of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-dstImage-00252", + "text": " If dstImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then for each element of pRegions, dstOffsets[0].z must be 0 and dstOffsets[1].z must be 1" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcImage-parameter", + "text": " srcImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcImageLayout-parameter", + "text": " srcImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-dstImage-parameter", + "text": " dstImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-dstImageLayout-parameter", + "text": " dstImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-pRegions-parameter", + "text": " pRegions must be a valid pointer to an array of regionCount valid VkImageBlit2KHR structures" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-filter-parameter", + "text": " filter must be a valid VkFilter value" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-regionCount-arraylength", + "text": " regionCount must be greater than 0" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-commonparent", + "text": " Both of dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_KHR_copy_commands2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcImage-06421", + "text": " srcImage must not use a format that requires a sampler Y’CBCR conversion" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-dstImage-06422", + "text": " dstImage must not use a format that requires a sampler Y’CBCR conversion" + } + ], + "(VK_KHR_copy_commands2)+!(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcImageLayout-00222", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-dstImageLayout-00227", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_KHR_copy_commands2)+(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-VkBlitImageInfo2KHR-srcImageLayout-01398", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-dstImageLayout-01399", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_KHR_copy_commands2)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-VkBlitImageInfo2KHR-filter-02002", + "text": " If filter is VK_FILTER_CUBIC_EXT, then the format features of srcImage must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-filter-00237", + "text": " If filter is VK_FILTER_CUBIC_EXT, srcImage must be of type VK_IMAGE_TYPE_2D" + } + ], + "(VK_KHR_copy_commands2)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkBlitImageInfo2KHR-dstImage-02545", + "text": " dstImage and srcImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT" + } + ], + "(VK_KHR_copy_commands2)+(VK_QCOM_rotated_copy_commands)": [ + { + "vuid": "VUID-VkBlitImageInfo2KHR-pRegions-04561", + "text": " If any element of pRegions contains VkCopyCommandTransformInfoQCOM in its pNext chain, then srcImage and dstImage must not be block-compressed images" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-pRegions-06207", + "text": " If any element of pRegions contains VkCopyCommandTransformInfoQCOM in its pNext chain, then srcImage must be of type VK_IMAGE_TYPE_2D" + }, + { + "vuid": "VUID-VkBlitImageInfo2KHR-pRegions-06208", + "text": " If any element of pRegions contains VkCopyCommandTransformInfoQCOM in its pNext chain, then srcImage must not have a multi-planar format" + } + ] + }, + "VkImageBlit2KHR": { + "(VK_KHR_copy_commands2)": [ + { + "vuid": "VUID-VkImageBlit2KHR-aspectMask-00238", + "text": " The aspectMask member of srcSubresource and dstSubresource must match" + }, + { + "vuid": "VUID-VkImageBlit2KHR-layerCount-00239", + "text": " The layerCount member of srcSubresource and dstSubresource must match" + }, + { + "vuid": "VUID-VkImageBlit2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR" + }, + { + "vuid": "VUID-VkImageBlit2KHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkImageBlit2KHR-srcSubresource-parameter", + "text": " srcSubresource must be a valid VkImageSubresourceLayers structure" + }, + { + "vuid": "VUID-VkImageBlit2KHR-dstSubresource-parameter", + "text": " dstSubresource must be a valid VkImageSubresourceLayers structure" + } + ] + }, + "vkCmdResolveImage": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdResolveImage-commandBuffer-01837", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, srcImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdResolveImage-commandBuffer-01838", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, dstImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdResolveImage-commandBuffer-01839", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, dstImage must not be an unprotected image" + } + ], + "core": [ + { + "vuid": "VUID-vkCmdResolveImage-pRegions-00255", + "text": " The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcImage-00256", + "text": " If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcImage-00257", + "text": " srcImage must have a sample count equal to any valid sample count value other than VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstImage-00258", + "text": " If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstImage-00259", + "text": " dstImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcImageLayout-00260", + "text": " srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstImageLayout-00262", + "text": " dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstImage-02003", + "text": " The format features of dstImage must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcImage-01386", + "text": " srcImage and dstImage must have been created with the same image format" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcSubresource-01709", + "text": " The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstSubresource-01710", + "text": " The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcSubresource-01711", + "text": " The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstSubresource-01712", + "text": " The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcImage-04446", + "text": " If either srcImage or dstImage are of type VK_IMAGE_TYPE_3D, then for each element of pRegions, srcSubresource.baseArrayLayer must be 0 and srcSubresource.layerCount must be 1" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcImage-04447", + "text": " If either srcImage or dstImage are of type VK_IMAGE_TYPE_3D, then for each element of pRegions, dstSubresource.baseArrayLayer must be 0 and dstSubresource.layerCount must be 1" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcOffset-00269", + "text": " For each element of pRegions, srcOffset.x and (extent.width + srcOffset.x) must both be greater than or equal to 0 and less than or equal to the width of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcOffset-00270", + "text": " For each element of pRegions, srcOffset.y and (extent.height + srcOffset.y) must both be greater than or equal to 0 and less than or equal to the height of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcImage-00271", + "text": " If srcImage is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, srcOffset.y must be 0 and extent.height must be 1" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcOffset-00272", + "text": " For each element of pRegions, srcOffset.z and (extent.depth + srcOffset.z) must both be greater than or equal to 0 and less than or equal to the depth of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcImage-00273", + "text": " If srcImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then for each element of pRegions, srcOffset.z must be 0 and extent.depth must be 1" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstOffset-00274", + "text": " For each element of pRegions, dstOffset.x and (extent.width + dstOffset.x) must both be greater than or equal to 0 and less than or equal to the width of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstOffset-00275", + "text": " For each element of pRegions, dstOffset.y and (extent.height + dstOffset.y) must both be greater than or equal to 0 and less than or equal to the height of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstImage-00276", + "text": " If dstImage is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, dstOffset.y must be 0 and extent.height must be 1" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstOffset-00277", + "text": " For each element of pRegions, dstOffset.z and (extent.depth + dstOffset.z) must both be greater than or equal to 0 and less than or equal to the depth of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstImage-00278", + "text": " If dstImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then for each element of pRegions, dstOffset.z must be 0 and extent.depth must be 1" + }, + { + "vuid": "VUID-vkCmdResolveImage-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcImage-parameter", + "text": " srcImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkCmdResolveImage-srcImageLayout-parameter", + "text": " srcImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstImage-parameter", + "text": " dstImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstImageLayout-parameter", + "text": " dstImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-vkCmdResolveImage-pRegions-parameter", + "text": " pRegions must be a valid pointer to an array of regionCount valid VkImageResolve structures" + }, + { + "vuid": "VUID-vkCmdResolveImage-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdResolveImage-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdResolveImage-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdResolveImage-regionCount-arraylength", + "text": " regionCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdResolveImage-commonparent", + "text": " Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "!(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdResolveImage-srcImageLayout-00261", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstImageLayout-00263", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkCmdResolveImage-srcImageLayout-01400", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-vkCmdResolveImage-dstImageLayout-01401", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdResolveImage-dstImage-02546", + "text": " dstImage and srcImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT" + } + ] + }, + "VkImageResolve": { + "core": [ + { + "vuid": "VUID-VkImageResolve-aspectMask-00266", + "text": " The aspectMask member of srcSubresource and dstSubresource must only contain VK_IMAGE_ASPECT_COLOR_BIT" + }, + { + "vuid": "VUID-VkImageResolve-layerCount-00267", + "text": " The layerCount member of srcSubresource and dstSubresource must match" + }, + { + "vuid": "VUID-VkImageResolve-srcSubresource-parameter", + "text": " srcSubresource must be a valid VkImageSubresourceLayers structure" + }, + { + "vuid": "VUID-VkImageResolve-dstSubresource-parameter", + "text": " dstSubresource must be a valid VkImageSubresourceLayers structure" + } + ] + }, + "vkCmdWriteBufferMarker2AMD": { + "(VK_AMD_buffer_marker)+(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-stage-03929", + "text": " If the geometry shaders feature is not enabled, pname:stage must not contain VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-stage-03930", + "text": " If the tessellation shaders feature is not enabled, pname:stage must not contain VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR or VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-synchronization2-03893", + "text": " The synchronization2 feature must be enabled" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-stage-03894", + "text": " stage must include only a single pipeline stage" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-stage-03895", + "text": " stage must include only stages that are valid for the queue family that was used to create the command pool that commandBuffer was allocated from" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-dstOffset-03896", + "text": " dstOffset must be less than or equal to the size of dstBuffer minus 4" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-dstBuffer-03897", + "text": " dstBuffer must have been created with the VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-dstBuffer-03898", + "text": " If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-dstOffset-03899", + "text": " dstOffset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-stage-parameter", + "text": " stage must be a valid combination of VkPipelineStageFlagBits2KHR values" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-dstBuffer-parameter", + "text": " dstBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-commonparent", + "text": " Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_AMD_buffer_marker)+(VK_KHR_synchronization2)+(VK_EXT_conditional_rendering)": [ + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-stage-03931", + "text": " If the conditional rendering feature is not enabled, pname:stage must not contain VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT" + } + ], + "(VK_AMD_buffer_marker)+(VK_KHR_synchronization2)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-stage-03932", + "text": " If the fragment density map feature is not enabled, pname:stage must not contain VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + } + ], + "(VK_AMD_buffer_marker)+(VK_KHR_synchronization2)+(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-stage-03933", + "text": " If the transform feedback feature is not enabled, pname:stage must not contain VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT" + } + ], + "(VK_AMD_buffer_marker)+(VK_KHR_synchronization2)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-stage-03934", + "text": " If the mesh shaders feature is not enabled, pname:stage must not contain VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-stage-03935", + "text": " If the task shaders feature is not enabled, pname:stage must not contain VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV" + } + ], + "(VK_AMD_buffer_marker)+(VK_KHR_synchronization2)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-stage-04956", + "text": " If the shading rate image feature is not enabled, pname:stage must not contain VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV" + } + ], + "(VK_AMD_buffer_marker)+(VK_KHR_synchronization2)+(VK_HUAWEI_subpass_shading)": [ + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-stage-04957", + "text": " If the subpass shading feature is not enabled, pname:stage must not contain VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI" + } + ], + "(VK_AMD_buffer_marker)+(VK_KHR_synchronization2)+(VK_HUAWEI_invocation_mask)": [ + { + "vuid": "VUID-vkCmdWriteBufferMarker2AMD-stage-04995", + "text": " If the invocation mask image feature is not enabled, pname:stage must not contain VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI" + } + ] + }, + "vkCmdWriteBufferMarkerAMD": { + "(VK_AMD_buffer_marker)": [ + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-04074", + "text": " pipelineStage must be a valid stage for the queue family that was used to create the command pool that commandBuffer was allocated from" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-04075", + "text": " If the geometry shaders feature is not enabled, pipelineStage must not be VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-04076", + "text": " If the tessellation shaders feature is not enabled, pipelineStage must not be VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-dstOffset-01798", + "text": " dstOffset must be less than or equal to the size of dstBuffer minus 4" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-01799", + "text": " dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-01800", + "text": " If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-dstOffset-01801", + "text": " dstOffset must be a multiple of 4" + } + ], + "(VK_AMD_buffer_marker)+(VK_EXT_conditional_rendering)": [ + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-04077", + "text": " If the conditional rendering feature is not enabled, pipelineStage must not be VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT" + } + ], + "(VK_AMD_buffer_marker)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-04078", + "text": " If the fragment density map feature is not enabled, pipelineStage must not be VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT" + } + ], + "(VK_AMD_buffer_marker)+(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-04079", + "text": " If the transform feedback feature is not enabled, pipelineStage must not be VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT" + } + ], + "(VK_AMD_buffer_marker)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-04080", + "text": " If the mesh shaders feature is not enabled, pipelineStage must not be VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV or VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV" + } + ], + "(VK_AMD_buffer_marker)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-04081", + "text": " If the shading rate image feature is not enabled, pipelineStage must not be VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV" + } + ], + "(VK_AMD_buffer_marker)+(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-synchronization2-06489", + "text": " If the synchronization2 feature is not enabled, pipelineStage must not be VK_PIPELINE_STAGE_NONE_KHR" + } + ], + "(VK_AMD_buffer_marker)+!(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-06490", + "text": " pipelineStage must not be VK_PIPELINE_STAGE_NONE_KHR" + } + ] + }, + "vkCmdResolveImage2KHR": { + "(VK_KHR_copy_commands2)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdResolveImage2KHR-commandBuffer-01837", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, srcImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdResolveImage2KHR-commandBuffer-01838", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, dstImage must not be a protected image" + }, + { + "vuid": "VUID-vkCmdResolveImage2KHR-commandBuffer-01839", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, dstImage must not be an unprotected image" + } + ], + "(VK_KHR_copy_commands2)": [ + { + "vuid": "VUID-vkCmdResolveImage2KHR-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdResolveImage2KHR-pResolveImageInfo-parameter", + "text": " pResolveImageInfo must be a valid pointer to a valid VkResolveImageInfo2KHR structure" + }, + { + "vuid": "VUID-vkCmdResolveImage2KHR-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdResolveImage2KHR-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdResolveImage2KHR-renderpass", + "text": " This command must only be called outside of a render pass instance" + } + ] + }, + "VkResolveImageInfo2KHR": { + "(VK_KHR_copy_commands2)": [ + { + "vuid": "VUID-VkResolveImageInfo2KHR-pRegions-00255", + "text": " The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-srcImage-00256", + "text": " If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-srcImage-00257", + "text": " srcImage must have a sample count equal to any valid sample count value other than VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-dstImage-00258", + "text": " If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-dstImage-00259", + "text": " dstImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-srcImageLayout-00260", + "text": " srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-dstImageLayout-00262", + "text": " dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-dstImage-02003", + "text": " The format features of dstImage must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-srcImage-01386", + "text": " srcImage and dstImage must have been created with the same image format" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-srcSubresource-01709", + "text": " The srcSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-dstSubresource-01710", + "text": " The dstSubresource.mipLevel member of each element of pRegions must be less than the mipLevels specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-srcSubresource-01711", + "text": " The srcSubresource.baseArrayLayer + srcSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when srcImage was created" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-dstSubresource-01712", + "text": " The dstSubresource.baseArrayLayer + dstSubresource.layerCount of each element of pRegions must be less than or equal to the arrayLayers specified in VkImageCreateInfo when dstImage was created" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-srcImage-04446", + "text": " If either srcImage or dstImage are of type VK_IMAGE_TYPE_3D, then for each element of pRegions, srcSubresource.baseArrayLayer must be 0 and srcSubresource.layerCount must be 1" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-srcImage-04447", + "text": " If either srcImage or dstImage are of type VK_IMAGE_TYPE_3D, then for each element of pRegions, dstSubresource.baseArrayLayer must be 0 and dstSubresource.layerCount must be 1" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-srcOffset-00269", + "text": " For each element of pRegions, srcOffset.x and (extent.width + srcOffset.x) must both be greater than or equal to 0 and less than or equal to the width of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-srcOffset-00270", + "text": " For each element of pRegions, srcOffset.y and (extent.height + srcOffset.y) must both be greater than or equal to 0 and less than or equal to the height of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-srcImage-00271", + "text": " If srcImage is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, srcOffset.y must be 0 and extent.height must be 1" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-srcOffset-00272", + "text": " For each element of pRegions, srcOffset.z and (extent.depth + srcOffset.z) must both be greater than or equal to 0 and less than or equal to the depth of the specified srcSubresource of srcImage" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-srcImage-00273", + "text": " If srcImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then for each element of pRegions, srcOffset.z must be 0 and extent.depth must be 1" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-dstOffset-00274", + "text": " For each element of pRegions, dstOffset.x and (extent.width + dstOffset.x) must both be greater than or equal to 0 and less than or equal to the width of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-dstOffset-00275", + "text": " For each element of pRegions, dstOffset.y and (extent.height + dstOffset.y) must both be greater than or equal to 0 and less than or equal to the height of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-dstImage-00276", + "text": " If dstImage is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, dstOffset.y must be 0 and extent.height must be 1" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-dstOffset-00277", + "text": " For each element of pRegions, dstOffset.z and (extent.depth + dstOffset.z) must both be greater than or equal to 0 and less than or equal to the depth of the specified dstSubresource of dstImage" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-dstImage-00278", + "text": " If dstImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then for each element of pRegions, dstOffset.z must be 0 and extent.depth must be 1" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-srcImage-parameter", + "text": " srcImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-srcImageLayout-parameter", + "text": " srcImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-dstImage-parameter", + "text": " dstImage must be a valid VkImage handle" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-dstImageLayout-parameter", + "text": " dstImageLayout must be a valid VkImageLayout value" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-pRegions-parameter", + "text": " pRegions must be a valid pointer to an array of regionCount valid VkImageResolve2KHR structures" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-regionCount-arraylength", + "text": " regionCount must be greater than 0" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-commonparent", + "text": " Both of dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_KHR_copy_commands2)+!(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-VkResolveImageInfo2KHR-srcImageLayout-00261", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-dstImageLayout-00263", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_KHR_copy_commands2)+(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-VkResolveImageInfo2KHR-srcImageLayout-01400", + "text": " srcImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-VkResolveImageInfo2KHR-dstImageLayout-01401", + "text": " dstImageLayout must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL" + } + ], + "(VK_KHR_copy_commands2)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkResolveImageInfo2KHR-dstImage-02546", + "text": " dstImage and srcImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT" + } + ] + }, + "VkImageResolve2KHR": { + "(VK_KHR_copy_commands2)": [ + { + "vuid": "VUID-VkImageResolve2KHR-aspectMask-00266", + "text": " The aspectMask member of srcSubresource and dstSubresource must only contain VK_IMAGE_ASPECT_COLOR_BIT" + }, + { + "vuid": "VUID-VkImageResolve2KHR-layerCount-00267", + "text": " The layerCount member of srcSubresource and dstSubresource must match" + }, + { + "vuid": "VUID-VkImageResolve2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR" + }, + { + "vuid": "VUID-VkImageResolve2KHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkImageResolve2KHR-srcSubresource-parameter", + "text": " srcSubresource must be a valid VkImageSubresourceLayers structure" + }, + { + "vuid": "VUID-VkImageResolve2KHR-dstSubresource-parameter", + "text": " dstSubresource must be a valid VkImageSubresourceLayers structure" + } + ] + }, + "vkCmdRefreshObjectsKHR": { + "(VK_KHR_object_refresh)": [ + { + "vuid": "VUID-vkCmdRefreshObjectsKHR-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdRefreshObjectsKHR-pRefreshObjects-parameter", + "text": " pRefreshObjects must be a valid pointer to a valid VkRefreshObjectListKHR structure" + }, + { + "vuid": "VUID-vkCmdRefreshObjectsKHR-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdRefreshObjectsKHR-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, compute, or transfer operations" + }, + { + "vuid": "VUID-vkCmdRefreshObjectsKHR-renderpass", + "text": " This command must only be called outside of a render pass instance" + } + ] + }, + "VkRefreshObjectListKHR": { + "(VK_KHR_object_refresh)": [ + { + "vuid": "VUID-VkRefreshObjectListKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR" + }, + { + "vuid": "VUID-VkRefreshObjectListKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkRefreshObjectListKHR-pObjects-parameter", + "text": " pObjects must be a valid pointer to an array of objectCount valid VkRefreshObjectKHR structures" + }, + { + "vuid": "VUID-VkRefreshObjectListKHR-objectCount-arraylength", + "text": " objectCount must be greater than 0" + } + ] + }, + "VkRefreshObjectKHR": { + "(VK_KHR_object_refresh)": [ + { + "vuid": "VUID-VkRefreshObjectKHR-objectHandle-05069", + "text": " objectHandle must be a valid Vulkan handle of the type associated with objectType as defined in the VkObjectType and Vulkan Handle Relationship table" + }, + { + "vuid": "VUID-VkRefreshObjectKHR-objectType-05070", + "text": " objectType must not be VK_OBJECT_TYPE_UNKNOWN" + }, + { + "vuid": "VUID-VkRefreshObjectKHR-objectType-parameter", + "text": " objectType must be a valid VkObjectType value" + }, + { + "vuid": "VUID-VkRefreshObjectKHR-flags-zerobitmask", + "text": " flags must be 0" + } + ] + }, + "VkPipelineInputAssemblyStateCreateInfo": { + "!(VK_EXT_primitive_topology_list_restart)": [ + { + "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00428", + "text": " If topology is VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY or VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, primitiveRestartEnable must be VK_FALSE" + } + ], + "(VK_EXT_primitive_topology_list_restart)": [ + { + "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-topology-06252", + "text": " If topology is VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, and primitiveRestartEnable is VK_TRUE, the primitiveTopologyListRestart feature must be enabled" + }, + { + "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-topology-06253", + "text": " If topology is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, and primitiveRestartEnable is VK_TRUE, the primitiveTopologyPatchListRestart feature must be enabled" + } + ], + "core": [ + { + "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00429", + "text": " If the geometry shaders feature is not enabled, topology must not be any of VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY" + }, + { + "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-topology-00430", + "text": " If the tessellation shaders feature is not enabled, topology must not be VK_PRIMITIVE_TOPOLOGY_PATCH_LIST" + }, + { + "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-topology-parameter", + "text": " topology must be a valid VkPrimitiveTopology value" + } + ], + "(VK_KHR_portability_subset)": [ + { + "vuid": "VUID-VkPipelineInputAssemblyStateCreateInfo-triangleFans-04452", + "text": " If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::triangleFans is VK_FALSE, topology must not be VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN" + } + ] + }, + "vkCmdSetPrimitiveRestartEnableEXT": { + "(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdSetPrimitiveRestartEnableEXT-None-04866", + "text": " The extendedDynamicState2 feature must be enabled" + }, + { + "vuid": "VUID-vkCmdSetPrimitiveRestartEnableEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetPrimitiveRestartEnableEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetPrimitiveRestartEnableEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkCmdSetPrimitiveTopologyEXT": { + "(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetPrimitiveTopologyEXT-None-03347", + "text": " The extendedDynamicState feature must be enabled" + }, + { + "vuid": "VUID-vkCmdSetPrimitiveTopologyEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetPrimitiveTopologyEXT-primitiveTopology-parameter", + "text": " primitiveTopology must be a valid VkPrimitiveTopology value" + }, + { + "vuid": "VUID-vkCmdSetPrimitiveTopologyEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetPrimitiveTopologyEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkCmdBindIndexBuffer": { + "core": [ + { + "vuid": "VUID-vkCmdBindIndexBuffer-offset-00431", + "text": " offset must be less than the size of buffer" + }, + { + "vuid": "VUID-vkCmdBindIndexBuffer-offset-00432", + "text": " The sum of offset and the address of the range of VkDeviceMemory object that is backing buffer, must be a multiple of the type indicated by indexType" + }, + { + "vuid": "VUID-vkCmdBindIndexBuffer-buffer-00433", + "text": " buffer must have been created with the VK_BUFFER_USAGE_INDEX_BUFFER_BIT flag" + }, + { + "vuid": "VUID-vkCmdBindIndexBuffer-buffer-00434", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBindIndexBuffer-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdBindIndexBuffer-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdBindIndexBuffer-indexType-parameter", + "text": " indexType must be a valid VkIndexType value" + }, + { + "vuid": "VUID-vkCmdBindIndexBuffer-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdBindIndexBuffer-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBindIndexBuffer-commonparent", + "text": " Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCmdBindIndexBuffer-indexType-02507", + "text": " indexType must not be VK_INDEX_TYPE_NONE_KHR" + } + ], + "(VK_EXT_index_type_uint8)": [ + { + "vuid": "VUID-vkCmdBindIndexBuffer-indexType-02765", + "text": " If indexType is VK_INDEX_TYPE_UINT8_EXT, the indexTypeUint8 feature must be enabled" + } + ] + }, + "vkCmdDraw": { + "core": [ + { + "vuid": "VUID-vkCmdDraw-magFilter-04553", + "text": " If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDraw-mipmapMode-04770", + "text": " If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDraw-None-02691", + "text": " If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" + }, + { + "vuid": "VUID-vkCmdDraw-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDraw-None-02699", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDraw-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDraw-commandBuffer-02701", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the VK_NV_inherited_viewport_scissor extension is enabled) for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic" + }, + { + "vuid": "VUID-vkCmdDraw-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDraw-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDraw-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDraw-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDraw-None-02705", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDraw-None-02706", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDraw-None-04115", + "text": " If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format" + }, + { + "vuid": "VUID-vkCmdDraw-OpImageWrite-04469", + "text": " If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format" + }, + { + "vuid": "VUID-vkCmdDraw-renderPass-02684", + "text": " The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDraw-subpass-02685", + "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDraw-None-02686", + "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" + }, + { + "vuid": "VUID-vkCmdDraw-None-04584", + "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command, except for cases involving read-only access to depth/stencil attachments as described in the Render Pass chapter" + }, + { + "vuid": "VUID-vkCmdDraw-blendEnable-04727", + "text": " If rasterization is not disabled in the bound graphics pipeline, then for each color attachment in the subpass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the blendEnable member of the corresponding element of the pAttachments member of pColorBlendState must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDraw-rasterizationSamples-04740", + "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then VkPipelineMultisampleStateCreateInfo::rasterizationSamples must be the same as the current subpass color and/or depth/stencil attachments" + }, + { + "vuid": "VUID-vkCmdDraw-None-04007", + "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have either valid or VK_NULL_HANDLE buffers bound" + }, + { + "vuid": "VUID-vkCmdDraw-None-04008", + "text": " If the nullDescriptor feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdDraw-None-02721", + "text": " For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in Vertex Input Description" + }, + { + "vuid": "VUID-vkCmdDraw-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDraw-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdDraw-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdDraw-renderpass", + "text": " This command must only be called inside of a render pass instance" + } + ], + "!(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDraw-aspectMask-06478", + "text": " If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT." + } + ], + "(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDraw-None-06479", + "text": " If a VkImageView is sampled with depth comparison, the image view’s format features must contain VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDraw-OpTypeImage-06423", + "text": " Any VkImageView or VkBufferView being written as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDraw-OpTypeImage-06424", + "text": " Any VkImageView or VkBufferView being read as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR" + } + ], + "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDraw-None-02692", + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + } + ], + "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+!(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDraw-None-02693", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDraw-filterCubic-02694", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2" + }, + { + "vuid": "VUID-vkCmdDraw-filterCubicMinmax-02695", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2" + } + ], + "(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-vkCmdDraw-flags-02696", + "text": " Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE" + } + ], + "!(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDraw-None-02698", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDraw-maintenance4-06425", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDraw-commandBuffer-02707", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" + }, + { + "vuid": "VUID-vkCmdDraw-commandBuffer-02712", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, any resource written to by the VkPipeline object bound to the pipeline bind point used by this command must not be an unprotected resource" + }, + { + "vuid": "VUID-vkCmdDraw-commandBuffer-02713", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, pipeline stages other than the framebuffer-space and compute stages in the VkPipeline object bound to the pipeline bind point used by this command must not write to any resource" + }, + { + "vuid": "VUID-vkCmdDraw-commandBuffer-04617", + "text": " If any of the shader stages of the VkPipeline bound to the pipeline bind point used by this command uses the RayQueryKHR capability, then commandBuffer must not be a protected command buffer" + } + ], + "(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-vkCmdDraw-SampledType-04470", + "text": " If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDraw-SampledType-04471", + "text": " If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDraw-SampledType-04472", + "text": " If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDraw-SampledType-04473", + "text": " If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDraw-sparseImageInt64Atomics-04474", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + }, + { + "vuid": "VUID-vkCmdDraw-sparseImageInt64Atomics-04475", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdDraw-maxMultiviewInstanceIndex-02688", + "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex" + } + ], + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdDraw-sampleLocationsEnable-02689", + "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" + } + ], + "(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDraw-viewportCount-03417", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the VkPipelineViewportStateCreateInfo::scissorCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDraw-scissorCount-03418", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the scissorCount parameter of vkCmdSetScissorWithCountEXT must match the VkPipelineViewportStateCreateInfo::viewportCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDraw-viewportCount-03419", + "text": " If the bound graphics pipeline state was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic states enabled then both vkCmdSetViewportWithCountEXT and vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the scissorCount parameter of vkCmdSetScissorWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDraw-primitiveTopology-03420", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT dynamic state enabled then vkCmdSetPrimitiveTopologyEXT must have been called in the current command buffer prior to this drawing command, and the primitiveTopology parameter of vkCmdSetPrimitiveTopologyEXT must be of the same topology class as the pipeline VkPipelineInputAssemblyStateCreateInfo::topology state" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ + { + "vuid": "VUID-vkCmdDraw-viewportCount-04137", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportWScalingStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDraw-viewportCount-04138", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdDraw-viewportCount-04139", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportShadingRateImageStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDraw-viewportCount-04140", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDraw-VkPipelineVieportCreateInfo-04141", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportSwizzleStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)": [ + { + "vuid": "VUID-vkCmdDraw-VkPipelineVieportCreateInfo-04142", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportExclusiveScissorStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportExclusiveScissorStateCreateInfoNV::exclusiveScissorCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdDraw-None-04876", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT dynamic state enabled then vkCmdSetRasterizerDiscardEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-04877", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT dynamic state enabled then vkCmdSetDepthBiasEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-logicOp-04878", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + }, + { + "vuid": "VUID-vkCmdDraw-None-04875", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT dynamic state enabled then vkCmdSetPatchControlPointsEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-04879", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDraw-primitiveFragmentShadingRateWithMultipleViewports-04552", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must be 1" + } + ], + "(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdDraw-imageView-06172", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDraw-imageView-06173", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + }, + { + "vuid": "VUID-vkCmdDraw-viewMask-06178", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::viewMask equal to VkRenderingInfoKHR::viewMask" + }, + { + "vuid": "VUID-vkCmdDraw-colorAttachmentCount-06179", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::colorAttachmentCount equal to VkRenderingInfoKHR::colorAttachmentCount" + }, + { + "vuid": "VUID-vkCmdDraw-colorAttachmentCount-06180", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::colorAttachmentCount greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a VkFormat equal to the corresponding element of VkPipelineRenderingCreateInfoKHR::pColorAttachmentFormats used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDraw-pDepthAttachment-06181", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::depthAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDraw-pStencilAttachment-06182", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::stencilAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-vkCmdDraw-imageView-06174", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDraw-imageView-06175", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-vkCmdDraw-imageView-06176", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDraw-imageView-06177", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-vkCmdDraw-imageView-06183", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentShadingRateAttachmentInfoKHR::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdDraw-imageView-06184", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentDensityMapAttachmentInfoEXT::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_AMD_mixed_attachment_samples,VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-vkCmdDraw-colorAttachmentCount-06185", + "text": " If the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the corresponding element of the pColorAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDraw-pDepthAttachment-06186", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDraw-pStencilAttachment-06187", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDraw-colorAttachmentCount-06188", + "text": " If the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDraw-pDepthAttachment-06189", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDraw-pStencilAttachment-06190", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDraw-renderPass-06198", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline must have been created with a VkGraphicsPipelineCreateInfo::renderPass equal to VK_NULL_HANDLE" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDraw-None-04912", + "text": " If the bound graphics pipeline was created with both the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT and VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic states enabled, then vkCmdSetVertexInputEXT must have been called in the current command buffer prior to this draw command" + }, + { + "vuid": "VUID-vkCmdDraw-pStrides-04913", + "text": " If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL" + } + ], + "(VK_EXT_extended_dynamic_state)+!(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDraw-pStrides-04884", + "text": " If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called in the current command buffer prior to this drawing command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL" + } + ], + "(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDraw-None-04914", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdSetVertexInputEXT must have been called in the current command buffer prior to this draw command" + } + ], + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDraw-stage-06481", + "text": " The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of an element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_TASK_BIT_NV or VK_SHADER_STAGE_MESH_BIT_NV" + } + ] + }, + "vkCmdDrawIndexed": { + "core": [ + { + "vuid": "VUID-vkCmdDrawIndexed-magFilter-04553", + "text": " If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-mipmapMode-04770", + "text": " If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-02691", + "text": " If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-02699", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-02701", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the VK_NV_inherited_viewport_scissor extension is enabled) for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-02705", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-02706", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-04115", + "text": " If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-OpImageWrite-04469", + "text": " If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-renderPass-02684", + "text": " The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-subpass-02685", + "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-02686", + "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-04584", + "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command, except for cases involving read-only access to depth/stencil attachments as described in the Render Pass chapter" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-blendEnable-04727", + "text": " If rasterization is not disabled in the bound graphics pipeline, then for each color attachment in the subpass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the blendEnable member of the corresponding element of the pAttachments member of pColorBlendState must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-rasterizationSamples-04740", + "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then VkPipelineMultisampleStateCreateInfo::rasterizationSamples must be the same as the current subpass color and/or depth/stencil attachments" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-04007", + "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have either valid or VK_NULL_HANDLE buffers bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-04008", + "text": " If the nullDescriptor feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-02721", + "text": " For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in Vertex Input Description" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-firstIndex-04932", + "text": " (indexSize {times} (firstIndex + indexCount) + offset) must be less than or equal to the size of the bound index buffer, with indexSize being based on the type specified by indexType, where the index buffer, indexType, and offset are specified via vkCmdBindIndexBuffer" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-renderpass", + "text": " This command must only be called inside of a render pass instance" + } + ], + "!(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-aspectMask-06478", + "text": " If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT." + } + ], + "(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-06479", + "text": " If a VkImageView is sampled with depth comparison, the image view’s format features must contain VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-OpTypeImage-06423", + "text": " Any VkImageView or VkBufferView being written as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-OpTypeImage-06424", + "text": " Any VkImageView or VkBufferView being read as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR" + } + ], + "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-02692", + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + } + ], + "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+!(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-02693", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-filterCubic-02694", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-filterCubicMinmax-02695", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2" + } + ], + "(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-flags-02696", + "text": " Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE" + } + ], + "!(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-02698", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-maintenance4-06425", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-02707", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-02712", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, any resource written to by the VkPipeline object bound to the pipeline bind point used by this command must not be an unprotected resource" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-02713", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, pipeline stages other than the framebuffer-space and compute stages in the VkPipeline object bound to the pipeline bind point used by this command must not write to any resource" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-04617", + "text": " If any of the shader stages of the VkPipeline bound to the pipeline bind point used by this command uses the RayQueryKHR capability, then commandBuffer must not be a protected command buffer" + } + ], + "(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-SampledType-04470", + "text": " If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-SampledType-04471", + "text": " If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-SampledType-04472", + "text": " If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-SampledType-04473", + "text": " If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-sparseImageInt64Atomics-04474", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-sparseImageInt64Atomics-04475", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-maxMultiviewInstanceIndex-02688", + "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex" + } + ], + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-sampleLocationsEnable-02689", + "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" + } + ], + "(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-viewportCount-03417", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the VkPipelineViewportStateCreateInfo::scissorCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-scissorCount-03418", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the scissorCount parameter of vkCmdSetScissorWithCountEXT must match the VkPipelineViewportStateCreateInfo::viewportCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-viewportCount-03419", + "text": " If the bound graphics pipeline state was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic states enabled then both vkCmdSetViewportWithCountEXT and vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the scissorCount parameter of vkCmdSetScissorWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-primitiveTopology-03420", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT dynamic state enabled then vkCmdSetPrimitiveTopologyEXT must have been called in the current command buffer prior to this drawing command, and the primitiveTopology parameter of vkCmdSetPrimitiveTopologyEXT must be of the same topology class as the pipeline VkPipelineInputAssemblyStateCreateInfo::topology state" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-viewportCount-04137", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportWScalingStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-viewportCount-04138", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-viewportCount-04139", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportShadingRateImageStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-viewportCount-04140", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-VkPipelineVieportCreateInfo-04141", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportSwizzleStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-VkPipelineVieportCreateInfo-04142", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportExclusiveScissorStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportExclusiveScissorStateCreateInfoNV::exclusiveScissorCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-04876", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT dynamic state enabled then vkCmdSetRasterizerDiscardEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-04877", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT dynamic state enabled then vkCmdSetDepthBiasEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-logicOp-04878", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-04875", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT dynamic state enabled then vkCmdSetPatchControlPointsEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-04879", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-primitiveFragmentShadingRateWithMultipleViewports-04552", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must be 1" + } + ], + "(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-imageView-06172", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-imageView-06173", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-viewMask-06178", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::viewMask equal to VkRenderingInfoKHR::viewMask" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-colorAttachmentCount-06179", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::colorAttachmentCount equal to VkRenderingInfoKHR::colorAttachmentCount" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-colorAttachmentCount-06180", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::colorAttachmentCount greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a VkFormat equal to the corresponding element of VkPipelineRenderingCreateInfoKHR::pColorAttachmentFormats used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-pDepthAttachment-06181", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::depthAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-pStencilAttachment-06182", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::stencilAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-imageView-06174", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-imageView-06175", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-imageView-06176", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-imageView-06177", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-imageView-06183", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentShadingRateAttachmentInfoKHR::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-imageView-06184", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentDensityMapAttachmentInfoEXT::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_AMD_mixed_attachment_samples,VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-colorAttachmentCount-06185", + "text": " If the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the corresponding element of the pColorAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-pDepthAttachment-06186", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-pStencilAttachment-06187", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-colorAttachmentCount-06188", + "text": " If the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-pDepthAttachment-06189", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-pStencilAttachment-06190", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-renderPass-06198", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline must have been created with a VkGraphicsPipelineCreateInfo::renderPass equal to VK_NULL_HANDLE" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-04912", + "text": " If the bound graphics pipeline was created with both the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT and VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic states enabled, then vkCmdSetVertexInputEXT must have been called in the current command buffer prior to this draw command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-pStrides-04913", + "text": " If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL" + } + ], + "(VK_EXT_extended_dynamic_state)+!(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-pStrides-04884", + "text": " If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called in the current command buffer prior to this drawing command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL" + } + ], + "(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-04914", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdSetVertexInputEXT must have been called in the current command buffer prior to this draw command" + } + ], + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-stage-06481", + "text": " The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of an element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_TASK_BIT_NV or VK_SHADER_STAGE_MESH_BIT_NV" + } + ] + }, + "vkCmdDrawMultiEXT": { + "(VK_EXT_multi_draw)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-magFilter-04553", + "text": " If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-mipmapMode-04770", + "text": " If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-02691", + "text": " If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-02699", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-commandBuffer-02701", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the VK_NV_inherited_viewport_scissor extension is enabled) for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-02705", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-02706", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-04115", + "text": " If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-OpImageWrite-04469", + "text": " If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-renderPass-02684", + "text": " The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-subpass-02685", + "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-02686", + "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-04584", + "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command, except for cases involving read-only access to depth/stencil attachments as described in the Render Pass chapter" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-blendEnable-04727", + "text": " If rasterization is not disabled in the bound graphics pipeline, then for each color attachment in the subpass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the blendEnable member of the corresponding element of the pAttachments member of pColorBlendState must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-rasterizationSamples-04740", + "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then VkPipelineMultisampleStateCreateInfo::rasterizationSamples must be the same as the current subpass color and/or depth/stencil attachments" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-04007", + "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have either valid or VK_NULL_HANDLE buffers bound" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-04008", + "text": " If the nullDescriptor feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-02721", + "text": " For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in Vertex Input Description" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-04933", + "text": " The multiDraw feature must be enabled" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-drawCount-04934", + "text": " drawCount must be less than VkPhysicalDeviceMultiDrawPropertiesEXT::maxMultiDrawCount" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-drawCount-04935", + "text": " If drawCount is greater than zero, pVertexInfo must be a valid pointer to memory containing one or more valid instances of VkMultiDrawInfoEXT structures" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-stride-04936", + "text": " stride must be a multiple of 4" + } + ], + "(VK_EXT_multi_draw)+!(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-aspectMask-06478", + "text": " If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT." + } + ], + "(VK_EXT_multi_draw)+(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-06479", + "text": " If a VkImageView is sampled with depth comparison, the image view’s format features must contain VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-OpTypeImage-06423", + "text": " Any VkImageView or VkBufferView being written as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-OpTypeImage-06424", + "text": " Any VkImageView or VkBufferView being read as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR" + } + ], + "(VK_EXT_multi_draw)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-02692", + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + } + ], + "(VK_EXT_multi_draw)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+!(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-02693", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_EXT_multi_draw)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-filterCubic-02694", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-filterCubicMinmax-02695", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2" + } + ], + "(VK_EXT_multi_draw)+(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-flags-02696", + "text": " Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE" + } + ], + "(VK_EXT_multi_draw)+!(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-02698", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_EXT_multi_draw)+(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-maintenance4-06425", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-commandBuffer-02707", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-commandBuffer-02712", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, any resource written to by the VkPipeline object bound to the pipeline bind point used by this command must not be an unprotected resource" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-commandBuffer-02713", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, pipeline stages other than the framebuffer-space and compute stages in the VkPipeline object bound to the pipeline bind point used by this command must not write to any resource" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-commandBuffer-04617", + "text": " If any of the shader stages of the VkPipeline bound to the pipeline bind point used by this command uses the RayQueryKHR capability, then commandBuffer must not be a protected command buffer" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-SampledType-04470", + "text": " If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-SampledType-04471", + "text": " If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-SampledType-04472", + "text": " If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-SampledType-04473", + "text": " If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-sparseImageInt64Atomics-04474", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-sparseImageInt64Atomics-04475", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + } + ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-maxMultiviewInstanceIndex-02688", + "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-sampleLocationsEnable-02689", + "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-viewportCount-03417", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the VkPipelineViewportStateCreateInfo::scissorCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-scissorCount-03418", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the scissorCount parameter of vkCmdSetScissorWithCountEXT must match the VkPipelineViewportStateCreateInfo::viewportCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-viewportCount-03419", + "text": " If the bound graphics pipeline state was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic states enabled then both vkCmdSetViewportWithCountEXT and vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the scissorCount parameter of vkCmdSetScissorWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-primitiveTopology-03420", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT dynamic state enabled then vkCmdSetPrimitiveTopologyEXT must have been called in the current command buffer prior to this drawing command, and the primitiveTopology parameter of vkCmdSetPrimitiveTopologyEXT must be of the same topology class as the pipeline VkPipelineInputAssemblyStateCreateInfo::topology state" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-viewportCount-04137", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportWScalingStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-viewportCount-04138", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-viewportCount-04139", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportShadingRateImageStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-viewportCount-04140", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-VkPipelineVieportCreateInfo-04141", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportSwizzleStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-VkPipelineVieportCreateInfo-04142", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportExclusiveScissorStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportExclusiveScissorStateCreateInfoNV::exclusiveScissorCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-04876", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT dynamic state enabled then vkCmdSetRasterizerDiscardEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-04877", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT dynamic state enabled then vkCmdSetDepthBiasEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-logicOp-04878", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-04875", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT dynamic state enabled then vkCmdSetPatchControlPointsEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-04879", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-primitiveFragmentShadingRateWithMultipleViewports-04552", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must be 1" + } + ], + "(VK_EXT_multi_draw)+(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-imageView-06172", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-imageView-06173", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-viewMask-06178", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::viewMask equal to VkRenderingInfoKHR::viewMask" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-colorAttachmentCount-06179", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::colorAttachmentCount equal to VkRenderingInfoKHR::colorAttachmentCount" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-colorAttachmentCount-06180", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::colorAttachmentCount greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a VkFormat equal to the corresponding element of VkPipelineRenderingCreateInfoKHR::pColorAttachmentFormats used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-pDepthAttachment-06181", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::depthAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-pStencilAttachment-06182", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::stencilAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + } + ], + "(VK_EXT_multi_draw)+(VK_KHR_dynamic_rendering)+(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-imageView-06174", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-imageView-06175", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_EXT_multi_draw)+(VK_KHR_dynamic_rendering)+(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-imageView-06176", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-imageView-06177", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_EXT_multi_draw)+(VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-imageView-06183", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentShadingRateAttachmentInfoKHR::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" + } + ], + "(VK_EXT_multi_draw)+(VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-imageView-06184", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentDensityMapAttachmentInfoEXT::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT" + } + ], + "(VK_EXT_multi_draw)+(VK_KHR_dynamic_rendering)+(VK_AMD_mixed_attachment_samples,VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-colorAttachmentCount-06185", + "text": " If the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the corresponding element of the pColorAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-pDepthAttachment-06186", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-pStencilAttachment-06187", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-colorAttachmentCount-06188", + "text": " If the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-pDepthAttachment-06189", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-pStencilAttachment-06190", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-renderPass-06198", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline must have been created with a VkGraphicsPipelineCreateInfo::renderPass equal to VK_NULL_HANDLE" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state)+(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-04912", + "text": " If the bound graphics pipeline was created with both the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT and VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic states enabled, then vkCmdSetVertexInputEXT must have been called in the current command buffer prior to this draw command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-pStrides-04913", + "text": " If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state)+!(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-pStrides-04884", + "text": " If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called in the current command buffer prior to this drawing command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-04914", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdSetVertexInputEXT must have been called in the current command buffer prior to this draw command" + } + ], + "(VK_EXT_multi_draw)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-stage-06481", + "text": " The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of an element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_TASK_BIT_NV or VK_SHADER_STAGE_MESH_BIT_NV" + } + ] + }, + "vkCmdDrawMultiIndexedEXT": { + "(VK_EXT_multi_draw)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-magFilter-04553", + "text": " If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-mipmapMode-04770", + "text": " If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02691", + "text": " If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02699", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-commandBuffer-02701", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the VK_NV_inherited_viewport_scissor extension is enabled) for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02705", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02706", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-04115", + "text": " If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-OpImageWrite-04469", + "text": " If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-renderPass-02684", + "text": " The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-subpass-02685", + "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02686", + "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-04584", + "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command, except for cases involving read-only access to depth/stencil attachments as described in the Render Pass chapter" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-blendEnable-04727", + "text": " If rasterization is not disabled in the bound graphics pipeline, then for each color attachment in the subpass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the blendEnable member of the corresponding element of the pAttachments member of pColorBlendState must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-rasterizationSamples-04740", + "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then VkPipelineMultisampleStateCreateInfo::rasterizationSamples must be the same as the current subpass color and/or depth/stencil attachments" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-04007", + "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have either valid or VK_NULL_HANDLE buffers bound" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-04008", + "text": " If the nullDescriptor feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02721", + "text": " For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in Vertex Input Description" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-04937", + "text": " The multiDraw feature must be enabled" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-firstIndex-04938", + "text": " (indexSize {times} (firstIndex + indexCount) + offset) must be less than or equal to the size of the bound index buffer, with indexSize being based on the type specified by indexType, where the index buffer, indexType, and offset are specified via vkCmdBindIndexBuffer" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-drawCount-04939", + "text": " drawCount must be less than VkPhysicalDeviceMultiDrawPropertiesEXT::maxMultiDrawCount" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-drawCount-04940", + "text": " If drawCount is greater than zero, pIndexInfo must be a valid pointer to memory containing one or more valid instances of VkMultiDrawIndexedInfoEXT structures" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-stride-04941", + "text": " stride must be a multiple of 4" + } + ], + "(VK_EXT_multi_draw)+!(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-aspectMask-06478", + "text": " If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT." + } + ], + "(VK_EXT_multi_draw)+(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-06479", + "text": " If a VkImageView is sampled with depth comparison, the image view’s format features must contain VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-OpTypeImage-06423", + "text": " Any VkImageView or VkBufferView being written as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-OpTypeImage-06424", + "text": " Any VkImageView or VkBufferView being read as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR" + } + ], + "(VK_EXT_multi_draw)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02692", + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + } + ], + "(VK_EXT_multi_draw)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+!(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02693", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_EXT_multi_draw)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-filterCubic-02694", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-filterCubicMinmax-02695", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2" + } + ], + "(VK_EXT_multi_draw)+(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-flags-02696", + "text": " Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE" + } + ], + "(VK_EXT_multi_draw)+!(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02698", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_EXT_multi_draw)+(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-maintenance4-06425", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-commandBuffer-02707", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-commandBuffer-02712", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, any resource written to by the VkPipeline object bound to the pipeline bind point used by this command must not be an unprotected resource" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-commandBuffer-02713", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, pipeline stages other than the framebuffer-space and compute stages in the VkPipeline object bound to the pipeline bind point used by this command must not write to any resource" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-commandBuffer-04617", + "text": " If any of the shader stages of the VkPipeline bound to the pipeline bind point used by this command uses the RayQueryKHR capability, then commandBuffer must not be a protected command buffer" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-SampledType-04470", + "text": " If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-SampledType-04471", + "text": " If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-SampledType-04472", + "text": " If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-SampledType-04473", + "text": " If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-sparseImageInt64Atomics-04474", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-sparseImageInt64Atomics-04475", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + } + ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-maxMultiviewInstanceIndex-02688", + "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-sampleLocationsEnable-02689", + "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-viewportCount-03417", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the VkPipelineViewportStateCreateInfo::scissorCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-scissorCount-03418", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the scissorCount parameter of vkCmdSetScissorWithCountEXT must match the VkPipelineViewportStateCreateInfo::viewportCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-viewportCount-03419", + "text": " If the bound graphics pipeline state was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic states enabled then both vkCmdSetViewportWithCountEXT and vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the scissorCount parameter of vkCmdSetScissorWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-primitiveTopology-03420", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT dynamic state enabled then vkCmdSetPrimitiveTopologyEXT must have been called in the current command buffer prior to this drawing command, and the primitiveTopology parameter of vkCmdSetPrimitiveTopologyEXT must be of the same topology class as the pipeline VkPipelineInputAssemblyStateCreateInfo::topology state" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-viewportCount-04137", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportWScalingStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-viewportCount-04138", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-viewportCount-04139", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportShadingRateImageStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-viewportCount-04140", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-VkPipelineVieportCreateInfo-04141", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportSwizzleStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-VkPipelineVieportCreateInfo-04142", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportExclusiveScissorStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportExclusiveScissorStateCreateInfoNV::exclusiveScissorCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-04876", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT dynamic state enabled then vkCmdSetRasterizerDiscardEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-04877", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT dynamic state enabled then vkCmdSetDepthBiasEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-logicOp-04878", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-04875", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT dynamic state enabled then vkCmdSetPatchControlPointsEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-04879", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-primitiveFragmentShadingRateWithMultipleViewports-04552", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must be 1" + } + ], + "(VK_EXT_multi_draw)+(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-imageView-06172", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-imageView-06173", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-viewMask-06178", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::viewMask equal to VkRenderingInfoKHR::viewMask" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-colorAttachmentCount-06179", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::colorAttachmentCount equal to VkRenderingInfoKHR::colorAttachmentCount" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-colorAttachmentCount-06180", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::colorAttachmentCount greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a VkFormat equal to the corresponding element of VkPipelineRenderingCreateInfoKHR::pColorAttachmentFormats used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-pDepthAttachment-06181", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::depthAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-pStencilAttachment-06182", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::stencilAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + } + ], + "(VK_EXT_multi_draw)+(VK_KHR_dynamic_rendering)+(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-imageView-06174", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-imageView-06175", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_EXT_multi_draw)+(VK_KHR_dynamic_rendering)+(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-imageView-06176", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-imageView-06177", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_EXT_multi_draw)+(VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-imageView-06183", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentShadingRateAttachmentInfoKHR::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" + } + ], + "(VK_EXT_multi_draw)+(VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-imageView-06184", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentDensityMapAttachmentInfoEXT::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT" + } + ], + "(VK_EXT_multi_draw)+(VK_KHR_dynamic_rendering)+(VK_AMD_mixed_attachment_samples,VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-colorAttachmentCount-06185", + "text": " If the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the corresponding element of the pColorAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-pDepthAttachment-06186", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-pStencilAttachment-06187", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-colorAttachmentCount-06188", + "text": " If the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-pDepthAttachment-06189", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-pStencilAttachment-06190", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-renderPass-06198", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline must have been created with a VkGraphicsPipelineCreateInfo::renderPass equal to VK_NULL_HANDLE" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state)+(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-04912", + "text": " If the bound graphics pipeline was created with both the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT and VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic states enabled, then vkCmdSetVertexInputEXT must have been called in the current command buffer prior to this draw command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-pStrides-04913", + "text": " If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state)+!(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-pStrides-04884", + "text": " If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called in the current command buffer prior to this drawing command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-04914", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdSetVertexInputEXT must have been called in the current command buffer prior to this draw command" + } + ], + "(VK_EXT_multi_draw)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-stage-06481", + "text": " The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of an element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_TASK_BIT_NV or VK_SHADER_STAGE_MESH_BIT_NV" + } + ] + }, + "vkCmdDrawIndirect": { + "core": [ + { + "vuid": "VUID-vkCmdDrawIndirect-magFilter-04553", + "text": " If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-mipmapMode-04770", + "text": " If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-02691", + "text": " If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-02699", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-02701", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the VK_NV_inherited_viewport_scissor extension is enabled) for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-02705", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-02706", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-04115", + "text": " If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-OpImageWrite-04469", + "text": " If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-renderPass-02684", + "text": " The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-subpass-02685", + "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-02686", + "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-04584", + "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command, except for cases involving read-only access to depth/stencil attachments as described in the Render Pass chapter" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-blendEnable-04727", + "text": " If rasterization is not disabled in the bound graphics pipeline, then for each color attachment in the subpass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the blendEnable member of the corresponding element of the pAttachments member of pColorBlendState must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-rasterizationSamples-04740", + "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then VkPipelineMultisampleStateCreateInfo::rasterizationSamples must be the same as the current subpass color and/or depth/stencil attachments" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-04007", + "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have either valid or VK_NULL_HANDLE buffers bound" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-04008", + "text": " If the nullDescriptor feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-02721", + "text": " For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in Vertex Input Description" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-buffer-02708", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-buffer-02709", + "text": " buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-offset-02710", + "text": " offset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-drawCount-02718", + "text": " If the multi-draw indirect feature is not enabled, drawCount must be 0 or 1" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-drawCount-02719", + "text": " drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-firstInstance-00478", + "text": " If the drawIndirectFirstInstance feature is not enabled, all the firstInstance members of the VkDrawIndirectCommand structures accessed by this command must be 0" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-drawCount-00476", + "text": " If drawCount is greater than 1, stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndirectCommand)" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-drawCount-00487", + "text": " If drawCount is equal to 1, (offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-drawCount-00488", + "text": " If drawCount is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-renderpass", + "text": " This command must only be called inside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-commonparent", + "text": " Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "!(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-aspectMask-06478", + "text": " If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT." + } + ], + "(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-06479", + "text": " If a VkImageView is sampled with depth comparison, the image view’s format features must contain VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-OpTypeImage-06423", + "text": " Any VkImageView or VkBufferView being written as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-OpTypeImage-06424", + "text": " Any VkImageView or VkBufferView being read as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR" + } + ], + "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-02692", + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + } + ], + "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+!(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-02693", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-filterCubic-02694", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-filterCubicMinmax-02695", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2" + } + ], + "(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-flags-02696", + "text": " Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE" + } + ], + "!(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-02698", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-maintenance4-06425", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-02707", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-02711", + "text": " commandBuffer must not be a protected command buffer" + } + ], + "(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-SampledType-04470", + "text": " If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-SampledType-04471", + "text": " If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-SampledType-04472", + "text": " If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-SampledType-04473", + "text": " If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-sparseImageInt64Atomics-04474", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-sparseImageInt64Atomics-04475", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-maxMultiviewInstanceIndex-02688", + "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex" + } + ], + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-sampleLocationsEnable-02689", + "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" + } + ], + "(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-viewportCount-03417", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the VkPipelineViewportStateCreateInfo::scissorCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-scissorCount-03418", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the scissorCount parameter of vkCmdSetScissorWithCountEXT must match the VkPipelineViewportStateCreateInfo::viewportCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-viewportCount-03419", + "text": " If the bound graphics pipeline state was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic states enabled then both vkCmdSetViewportWithCountEXT and vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the scissorCount parameter of vkCmdSetScissorWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-primitiveTopology-03420", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT dynamic state enabled then vkCmdSetPrimitiveTopologyEXT must have been called in the current command buffer prior to this drawing command, and the primitiveTopology parameter of vkCmdSetPrimitiveTopologyEXT must be of the same topology class as the pipeline VkPipelineInputAssemblyStateCreateInfo::topology state" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-viewportCount-04137", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportWScalingStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-viewportCount-04138", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-viewportCount-04139", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportShadingRateImageStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-viewportCount-04140", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-VkPipelineVieportCreateInfo-04141", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportSwizzleStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-VkPipelineVieportCreateInfo-04142", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportExclusiveScissorStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportExclusiveScissorStateCreateInfoNV::exclusiveScissorCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-04876", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT dynamic state enabled then vkCmdSetRasterizerDiscardEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-04877", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT dynamic state enabled then vkCmdSetDepthBiasEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-logicOp-04878", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-04875", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT dynamic state enabled then vkCmdSetPatchControlPointsEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-04879", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-primitiveFragmentShadingRateWithMultipleViewports-04552", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must be 1" + } + ], + "(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-imageView-06172", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-imageView-06173", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-viewMask-06178", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::viewMask equal to VkRenderingInfoKHR::viewMask" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-colorAttachmentCount-06179", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::colorAttachmentCount equal to VkRenderingInfoKHR::colorAttachmentCount" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-colorAttachmentCount-06180", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::colorAttachmentCount greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a VkFormat equal to the corresponding element of VkPipelineRenderingCreateInfoKHR::pColorAttachmentFormats used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-pDepthAttachment-06181", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::depthAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-pStencilAttachment-06182", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::stencilAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-imageView-06174", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-imageView-06175", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-imageView-06176", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-imageView-06177", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-imageView-06183", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentShadingRateAttachmentInfoKHR::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-imageView-06184", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentDensityMapAttachmentInfoEXT::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_AMD_mixed_attachment_samples,VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-colorAttachmentCount-06185", + "text": " If the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the corresponding element of the pColorAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-pDepthAttachment-06186", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-pStencilAttachment-06187", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-colorAttachmentCount-06188", + "text": " If the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-pDepthAttachment-06189", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-pStencilAttachment-06190", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-renderPass-06198", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline must have been created with a VkGraphicsPipelineCreateInfo::renderPass equal to VK_NULL_HANDLE" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-04912", + "text": " If the bound graphics pipeline was created with both the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT and VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic states enabled, then vkCmdSetVertexInputEXT must have been called in the current command buffer prior to this draw command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-pStrides-04913", + "text": " If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL" + } + ], + "(VK_EXT_extended_dynamic_state)+!(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-pStrides-04884", + "text": " If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called in the current command buffer prior to this drawing command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL" + } + ], + "(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-04914", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdSetVertexInputEXT must have been called in the current command buffer prior to this draw command" + } + ], + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-stage-06481", + "text": " The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of an element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_TASK_BIT_NV or VK_SHADER_STAGE_MESH_BIT_NV" + } + ] + }, + "VkDrawIndirectCommand": { + "core": [ + { + "vuid": "VUID-VkDrawIndirectCommand-None-00500", + "text": " For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in Vertex Input Description" + }, + { + "vuid": "VUID-VkDrawIndirectCommand-firstInstance-00501", + "text": " If the drawIndirectFirstInstance feature is not enabled, firstInstance must be 0" + } + ] + }, + "vkCmdDrawIndirectCount": { + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-magFilter-04553", + "text": " If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-mipmapMode-04770", + "text": " If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-02691", + "text": " If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-02699", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-commandBuffer-02701", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the VK_NV_inherited_viewport_scissor extension is enabled) for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-02705", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-02706", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-04115", + "text": " If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-OpImageWrite-04469", + "text": " If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-renderPass-02684", + "text": " The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-subpass-02685", + "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-02686", + "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-04584", + "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command, except for cases involving read-only access to depth/stencil attachments as described in the Render Pass chapter" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-blendEnable-04727", + "text": " If rasterization is not disabled in the bound graphics pipeline, then for each color attachment in the subpass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the blendEnable member of the corresponding element of the pAttachments member of pColorBlendState must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-rasterizationSamples-04740", + "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then VkPipelineMultisampleStateCreateInfo::rasterizationSamples must be the same as the current subpass color and/or depth/stencil attachments" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-04007", + "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have either valid or VK_NULL_HANDLE buffers bound" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-04008", + "text": " If the nullDescriptor feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-02721", + "text": " For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in Vertex Input Description" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-buffer-02708", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-buffer-02709", + "text": " buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-offset-02710", + "text": " offset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-countBuffer-02714", + "text": " If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-countBuffer-02715", + "text": " countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-countBufferOffset-02716", + "text": " countBufferOffset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-countBuffer-02717", + "text": " The count stored in countBuffer must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-countBufferOffset-04129", + "text": " (countBufferOffset + sizeof(uint32_t)) must be less than or equal to the size of countBuffer" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-stride-03110", + "text": " stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndirectCommand)" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-maxDrawCount-03111", + "text": " If maxDrawCount is greater than or equal to 1, (stride {times} (maxDrawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-countBuffer-03121", + "text": " If the count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-countBuffer-03122", + "text": " If the count stored in countBuffer is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-countBuffer-parameter", + "text": " countBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-renderpass", + "text": " This command must only be called inside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-commonparent", + "text": " Each of buffer, commandBuffer, and countBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+!(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-aspectMask-06478", + "text": " If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT." + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-06479", + "text": " If a VkImageView is sampled with depth comparison, the image view’s format features must contain VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-OpTypeImage-06423", + "text": " Any VkImageView or VkBufferView being written as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-OpTypeImage-06424", + "text": " Any VkImageView or VkBufferView being read as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-02692", + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+!(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-02693", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-filterCubic-02694", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-filterCubicMinmax-02695", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-flags-02696", + "text": " Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+!(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-02698", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-maintenance4-06425", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-commandBuffer-02707", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-commandBuffer-02711", + "text": " commandBuffer must not be a protected command buffer" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-SampledType-04470", + "text": " If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-SampledType-04471", + "text": " If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-SampledType-04472", + "text": " If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-SampledType-04473", + "text": " If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-sparseImageInt64Atomics-04474", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-sparseImageInt64Atomics-04475", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-maxMultiviewInstanceIndex-02688", + "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-sampleLocationsEnable-02689", + "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-viewportCount-03417", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the VkPipelineViewportStateCreateInfo::scissorCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-scissorCount-03418", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the scissorCount parameter of vkCmdSetScissorWithCountEXT must match the VkPipelineViewportStateCreateInfo::viewportCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-viewportCount-03419", + "text": " If the bound graphics pipeline state was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic states enabled then both vkCmdSetViewportWithCountEXT and vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the scissorCount parameter of vkCmdSetScissorWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-primitiveTopology-03420", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT dynamic state enabled then vkCmdSetPrimitiveTopologyEXT must have been called in the current command buffer prior to this drawing command, and the primitiveTopology parameter of vkCmdSetPrimitiveTopologyEXT must be of the same topology class as the pipeline VkPipelineInputAssemblyStateCreateInfo::topology state" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-viewportCount-04137", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportWScalingStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-viewportCount-04138", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-viewportCount-04139", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportShadingRateImageStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-viewportCount-04140", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-VkPipelineVieportCreateInfo-04141", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportSwizzleStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-VkPipelineVieportCreateInfo-04142", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportExclusiveScissorStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportExclusiveScissorStateCreateInfoNV::exclusiveScissorCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-04876", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT dynamic state enabled then vkCmdSetRasterizerDiscardEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-04877", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT dynamic state enabled then vkCmdSetDepthBiasEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-logicOp-04878", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-04875", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT dynamic state enabled then vkCmdSetPatchControlPointsEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-04879", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-primitiveFragmentShadingRateWithMultipleViewports-04552", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must be 1" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-imageView-06172", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-imageView-06173", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-viewMask-06178", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::viewMask equal to VkRenderingInfoKHR::viewMask" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-colorAttachmentCount-06179", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::colorAttachmentCount equal to VkRenderingInfoKHR::colorAttachmentCount" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-colorAttachmentCount-06180", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::colorAttachmentCount greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a VkFormat equal to the corresponding element of VkPipelineRenderingCreateInfoKHR::pColorAttachmentFormats used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-pDepthAttachment-06181", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::depthAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-pStencilAttachment-06182", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::stencilAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_dynamic_rendering)+(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-imageView-06174", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-imageView-06175", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_dynamic_rendering)+(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-imageView-06176", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-imageView-06177", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-imageView-06183", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentShadingRateAttachmentInfoKHR::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-imageView-06184", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentDensityMapAttachmentInfoEXT::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_dynamic_rendering)+(VK_AMD_mixed_attachment_samples,VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-colorAttachmentCount-06185", + "text": " If the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the corresponding element of the pColorAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-pDepthAttachment-06186", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-pStencilAttachment-06187", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-colorAttachmentCount-06188", + "text": " If the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-pDepthAttachment-06189", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-pStencilAttachment-06190", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-renderPass-06198", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline must have been created with a VkGraphicsPipelineCreateInfo::renderPass equal to VK_NULL_HANDLE" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state)+(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-04912", + "text": " If the bound graphics pipeline was created with both the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT and VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic states enabled, then vkCmdSetVertexInputEXT must have been called in the current command buffer prior to this draw command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-pStrides-04913", + "text": " If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state)+!(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-pStrides-04884", + "text": " If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called in the current command buffer prior to this drawing command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-04914", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdSetVertexInputEXT must have been called in the current command buffer prior to this draw command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-stage-06481", + "text": " The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of an element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_TASK_BIT_NV or VK_SHADER_STAGE_MESH_BIT_NV" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_2)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-04445", + "text": " If drawIndirectCount is not enabled this function must not be used" + } + ] + }, + "vkCmdDrawIndexedIndirect": { + "core": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-magFilter-04553", + "text": " If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-mipmapMode-04770", + "text": " If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02691", + "text": " If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02699", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-02701", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the VK_NV_inherited_viewport_scissor extension is enabled) for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02705", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02706", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-04115", + "text": " If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-OpImageWrite-04469", + "text": " If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-renderPass-02684", + "text": " The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-subpass-02685", + "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02686", + "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-04584", + "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command, except for cases involving read-only access to depth/stencil attachments as described in the Render Pass chapter" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-blendEnable-04727", + "text": " If rasterization is not disabled in the bound graphics pipeline, then for each color attachment in the subpass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the blendEnable member of the corresponding element of the pAttachments member of pColorBlendState must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-rasterizationSamples-04740", + "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then VkPipelineMultisampleStateCreateInfo::rasterizationSamples must be the same as the current subpass color and/or depth/stencil attachments" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-04007", + "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have either valid or VK_NULL_HANDLE buffers bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-04008", + "text": " If the nullDescriptor feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02721", + "text": " For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in Vertex Input Description" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-buffer-02708", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-buffer-02709", + "text": " buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-offset-02710", + "text": " offset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-drawCount-02718", + "text": " If the multi-draw indirect feature is not enabled, drawCount must be 0 or 1" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-drawCount-02719", + "text": " drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-drawCount-00528", + "text": " If drawCount is greater than 1, stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndexedIndirectCommand)" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-firstInstance-00530", + "text": " If the drawIndirectFirstInstance feature is not enabled, all the firstInstance members of the VkDrawIndexedIndirectCommand structures accessed by this command must be 0" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-drawCount-00539", + "text": " If drawCount is equal to 1, (offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-drawCount-00540", + "text": " If drawCount is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-renderpass", + "text": " This command must only be called inside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-commonparent", + "text": " Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "!(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-aspectMask-06478", + "text": " If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT." + } + ], + "(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-06479", + "text": " If a VkImageView is sampled with depth comparison, the image view’s format features must contain VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-OpTypeImage-06423", + "text": " Any VkImageView or VkBufferView being written as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-OpTypeImage-06424", + "text": " Any VkImageView or VkBufferView being read as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR" + } + ], + "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02692", + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + } + ], + "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+!(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02693", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-filterCubic-02694", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-filterCubicMinmax-02695", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2" + } + ], + "(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-flags-02696", + "text": " Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE" + } + ], + "!(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02698", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-maintenance4-06425", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-02707", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-02711", + "text": " commandBuffer must not be a protected command buffer" + } + ], + "(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-SampledType-04470", + "text": " If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-SampledType-04471", + "text": " If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-SampledType-04472", + "text": " If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-SampledType-04473", + "text": " If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-sparseImageInt64Atomics-04474", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-sparseImageInt64Atomics-04475", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + } + ], + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-maxMultiviewInstanceIndex-02688", + "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex" + } + ], + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-sampleLocationsEnable-02689", + "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" + } + ], + "(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-viewportCount-03417", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the VkPipelineViewportStateCreateInfo::scissorCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-scissorCount-03418", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the scissorCount parameter of vkCmdSetScissorWithCountEXT must match the VkPipelineViewportStateCreateInfo::viewportCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-viewportCount-03419", + "text": " If the bound graphics pipeline state was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic states enabled then both vkCmdSetViewportWithCountEXT and vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the scissorCount parameter of vkCmdSetScissorWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-primitiveTopology-03420", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT dynamic state enabled then vkCmdSetPrimitiveTopologyEXT must have been called in the current command buffer prior to this drawing command, and the primitiveTopology parameter of vkCmdSetPrimitiveTopologyEXT must be of the same topology class as the pipeline VkPipelineInputAssemblyStateCreateInfo::topology state" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-viewportCount-04137", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportWScalingStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-viewportCount-04138", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-viewportCount-04139", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportShadingRateImageStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-viewportCount-04140", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-VkPipelineVieportCreateInfo-04141", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportSwizzleStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-VkPipelineVieportCreateInfo-04142", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportExclusiveScissorStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportExclusiveScissorStateCreateInfoNV::exclusiveScissorCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-04876", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT dynamic state enabled then vkCmdSetRasterizerDiscardEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-04877", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT dynamic state enabled then vkCmdSetDepthBiasEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-logicOp-04878", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-04875", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT dynamic state enabled then vkCmdSetPatchControlPointsEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-04879", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-primitiveFragmentShadingRateWithMultipleViewports-04552", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must be 1" + } + ], + "(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-imageView-06172", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-imageView-06173", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-viewMask-06178", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::viewMask equal to VkRenderingInfoKHR::viewMask" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-colorAttachmentCount-06179", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::colorAttachmentCount equal to VkRenderingInfoKHR::colorAttachmentCount" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-colorAttachmentCount-06180", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::colorAttachmentCount greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a VkFormat equal to the corresponding element of VkPipelineRenderingCreateInfoKHR::pColorAttachmentFormats used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-pDepthAttachment-06181", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::depthAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-pStencilAttachment-06182", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::stencilAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-imageView-06174", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-imageView-06175", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-imageView-06176", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-imageView-06177", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-imageView-06183", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentShadingRateAttachmentInfoKHR::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-imageView-06184", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentDensityMapAttachmentInfoEXT::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT" + } + ], + "(VK_KHR_dynamic_rendering)+(VK_AMD_mixed_attachment_samples,VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-colorAttachmentCount-06185", + "text": " If the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the corresponding element of the pColorAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-pDepthAttachment-06186", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-pStencilAttachment-06187", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-colorAttachmentCount-06188", + "text": " If the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-pDepthAttachment-06189", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-pStencilAttachment-06190", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-renderPass-06198", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline must have been created with a VkGraphicsPipelineCreateInfo::renderPass equal to VK_NULL_HANDLE" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-04912", + "text": " If the bound graphics pipeline was created with both the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT and VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic states enabled, then vkCmdSetVertexInputEXT must have been called in the current command buffer prior to this draw command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-pStrides-04913", + "text": " If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL" + } + ], + "(VK_EXT_extended_dynamic_state)+!(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-pStrides-04884", + "text": " If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called in the current command buffer prior to this drawing command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL" + } + ], + "(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-04914", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdSetVertexInputEXT must have been called in the current command buffer prior to this draw command" + } + ], + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-stage-06481", + "text": " The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of an element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_TASK_BIT_NV or VK_SHADER_STAGE_MESH_BIT_NV" + } + ] + }, + "VkDrawIndexedIndirectCommand": { + "core": [ + { + "vuid": "VUID-VkDrawIndexedIndirectCommand-None-00552", + "text": " For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in Vertex Input Description" + }, + { + "vuid": "VUID-VkDrawIndexedIndirectCommand-indexSize-00553", + "text": " (indexSize {times} (firstIndex + indexCount) + offset) must be less than or equal to the size of the bound index buffer, with indexSize being based on the type specified by indexType, where the index buffer, indexType, and offset are specified via vkCmdBindIndexBuffer" + }, + { + "vuid": "VUID-VkDrawIndexedIndirectCommand-firstInstance-00554", + "text": " If the drawIndirectFirstInstance feature is not enabled, firstInstance must be 0" + } + ] + }, + "vkCmdDrawIndexedIndirectCount": { + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-magFilter-04553", + "text": " If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-mipmapMode-04770", + "text": " If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02691", + "text": " If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02699", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-02701", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the VK_NV_inherited_viewport_scissor extension is enabled) for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02705", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02706", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-04115", + "text": " If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-OpImageWrite-04469", + "text": " If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-renderPass-02684", + "text": " The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-subpass-02685", + "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02686", + "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-04584", + "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command, except for cases involving read-only access to depth/stencil attachments as described in the Render Pass chapter" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-blendEnable-04727", + "text": " If rasterization is not disabled in the bound graphics pipeline, then for each color attachment in the subpass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the blendEnable member of the corresponding element of the pAttachments member of pColorBlendState must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-rasterizationSamples-04740", + "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then VkPipelineMultisampleStateCreateInfo::rasterizationSamples must be the same as the current subpass color and/or depth/stencil attachments" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-04007", + "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have either valid or VK_NULL_HANDLE buffers bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-04008", + "text": " If the nullDescriptor feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02721", + "text": " For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in Vertex Input Description" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-buffer-02708", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-buffer-02709", + "text": " buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-offset-02710", + "text": " offset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-countBuffer-02714", + "text": " If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-countBuffer-02715", + "text": " countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-countBufferOffset-02716", + "text": " countBufferOffset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-countBuffer-02717", + "text": " The count stored in countBuffer must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-countBufferOffset-04129", + "text": " (countBufferOffset + sizeof(uint32_t)) must be less than or equal to the size of countBuffer" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-stride-03142", + "text": " stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndexedIndirectCommand)" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-maxDrawCount-03143", + "text": " If maxDrawCount is greater than or equal to 1, (stride {times} (maxDrawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-countBuffer-03153", + "text": " If count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-countBuffer-03154", + "text": " If count stored in countBuffer is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-countBuffer-parameter", + "text": " countBuffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-renderpass", + "text": " This command must only be called inside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-commonparent", + "text": " Each of buffer, commandBuffer, and countBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+!(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-aspectMask-06478", + "text": " If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT." + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-06479", + "text": " If a VkImageView is sampled with depth comparison, the image view’s format features must contain VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-OpTypeImage-06423", + "text": " Any VkImageView or VkBufferView being written as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-OpTypeImage-06424", + "text": " Any VkImageView or VkBufferView being read as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02692", + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+!(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02693", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-filterCubic-02694", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-filterCubicMinmax-02695", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-flags-02696", + "text": " Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+!(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02698", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-maintenance4-06425", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-02707", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-02711", + "text": " commandBuffer must not be a protected command buffer" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-SampledType-04470", + "text": " If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-SampledType-04471", + "text": " If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-SampledType-04472", + "text": " If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-SampledType-04473", + "text": " If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-sparseImageInt64Atomics-04474", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-sparseImageInt64Atomics-04475", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-maxMultiviewInstanceIndex-02688", + "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-sampleLocationsEnable-02689", + "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-viewportCount-03417", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the VkPipelineViewportStateCreateInfo::scissorCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-scissorCount-03418", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the scissorCount parameter of vkCmdSetScissorWithCountEXT must match the VkPipelineViewportStateCreateInfo::viewportCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-viewportCount-03419", + "text": " If the bound graphics pipeline state was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic states enabled then both vkCmdSetViewportWithCountEXT and vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the scissorCount parameter of vkCmdSetScissorWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-primitiveTopology-03420", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT dynamic state enabled then vkCmdSetPrimitiveTopologyEXT must have been called in the current command buffer prior to this drawing command, and the primitiveTopology parameter of vkCmdSetPrimitiveTopologyEXT must be of the same topology class as the pipeline VkPipelineInputAssemblyStateCreateInfo::topology state" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-viewportCount-04137", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportWScalingStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-viewportCount-04138", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-viewportCount-04139", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportShadingRateImageStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-viewportCount-04140", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-VkPipelineVieportCreateInfo-04141", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportSwizzleStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-VkPipelineVieportCreateInfo-04142", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportExclusiveScissorStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportExclusiveScissorStateCreateInfoNV::exclusiveScissorCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-04876", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT dynamic state enabled then vkCmdSetRasterizerDiscardEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-04877", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT dynamic state enabled then vkCmdSetDepthBiasEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-logicOp-04878", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-04875", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT dynamic state enabled then vkCmdSetPatchControlPointsEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-04879", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-primitiveFragmentShadingRateWithMultipleViewports-04552", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must be 1" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-imageView-06172", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-imageView-06173", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-viewMask-06178", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::viewMask equal to VkRenderingInfoKHR::viewMask" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-colorAttachmentCount-06179", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::colorAttachmentCount equal to VkRenderingInfoKHR::colorAttachmentCount" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-colorAttachmentCount-06180", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::colorAttachmentCount greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a VkFormat equal to the corresponding element of VkPipelineRenderingCreateInfoKHR::pColorAttachmentFormats used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-pDepthAttachment-06181", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::depthAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-pStencilAttachment-06182", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::stencilAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_dynamic_rendering)+(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-imageView-06174", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-imageView-06175", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_dynamic_rendering)+(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-imageView-06176", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-imageView-06177", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-imageView-06183", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentShadingRateAttachmentInfoKHR::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-imageView-06184", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentDensityMapAttachmentInfoEXT::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_dynamic_rendering)+(VK_AMD_mixed_attachment_samples,VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-colorAttachmentCount-06185", + "text": " If the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the corresponding element of the pColorAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-pDepthAttachment-06186", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-pStencilAttachment-06187", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-colorAttachmentCount-06188", + "text": " If the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-pDepthAttachment-06189", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-pStencilAttachment-06190", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-renderPass-06198", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline must have been created with a VkGraphicsPipelineCreateInfo::renderPass equal to VK_NULL_HANDLE" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state)+(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-04912", + "text": " If the bound graphics pipeline was created with both the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT and VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic states enabled, then vkCmdSetVertexInputEXT must have been called in the current command buffer prior to this draw command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-pStrides-04913", + "text": " If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state)+!(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-pStrides-04884", + "text": " If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called in the current command buffer prior to this drawing command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-04914", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdSetVertexInputEXT must have been called in the current command buffer prior to this draw command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-stage-06481", + "text": " The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of an element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_TASK_BIT_NV or VK_SHADER_STAGE_MESH_BIT_NV" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_2)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-04445", + "text": " If drawIndirectCount is not enabled this function must not be used" + } + ] + }, + "vkCmdDrawIndirectByteCountEXT": { + "(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-magFilter-04553", + "text": " If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-mipmapMode-04770", + "text": " If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02691", + "text": " If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02699", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-commandBuffer-02701", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the VK_NV_inherited_viewport_scissor extension is enabled) for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02705", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02706", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-04115", + "text": " If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-OpImageWrite-04469", + "text": " If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-renderPass-02684", + "text": " The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-subpass-02685", + "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02686", + "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-04584", + "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command, except for cases involving read-only access to depth/stencil attachments as described in the Render Pass chapter" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-blendEnable-04727", + "text": " If rasterization is not disabled in the bound graphics pipeline, then for each color attachment in the subpass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the blendEnable member of the corresponding element of the pAttachments member of pColorBlendState must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-rasterizationSamples-04740", + "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then VkPipelineMultisampleStateCreateInfo::rasterizationSamples must be the same as the current subpass color and/or depth/stencil attachments" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-04007", + "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have either valid or VK_NULL_HANDLE buffers bound" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-04008", + "text": " If the nullDescriptor feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02721", + "text": " For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in Vertex Input Description" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-transformFeedback-02287", + "text": " VkPhysicalDeviceTransformFeedbackFeaturesEXT::transformFeedback must be enabled" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-transformFeedbackDraw-02288", + "text": " The implementation must support VkPhysicalDeviceTransformFeedbackPropertiesEXT::transformFeedbackDraw" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-vertexStride-02289", + "text": " vertexStride must be greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxTransformFeedbackBufferDataStride" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-counterBuffer-04567", + "text": " If counterBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-counterBuffer-02290", + "text": " counterBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-counterBufferOffset-04568", + "text": " counterBufferOffset must be a multiple of 4" + } + ], + "(VK_EXT_transform_feedback)+!(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-aspectMask-06478", + "text": " If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT." + } + ], + "(VK_EXT_transform_feedback)+(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-06479", + "text": " If a VkImageView is sampled with depth comparison, the image view’s format features must contain VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-OpTypeImage-06423", + "text": " Any VkImageView or VkBufferView being written as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-OpTypeImage-06424", + "text": " Any VkImageView or VkBufferView being read as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR" + } + ], + "(VK_EXT_transform_feedback)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02692", + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + } + ], + "(VK_EXT_transform_feedback)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+!(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02693", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_EXT_transform_feedback)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-filterCubic-02694", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-filterCubicMinmax-02695", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2" + } + ], + "(VK_EXT_transform_feedback)+(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-flags-02696", + "text": " Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE" + } + ], + "(VK_EXT_transform_feedback)+!(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02698", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_EXT_transform_feedback)+(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-maintenance4-06425", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_EXT_transform_feedback)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-commandBuffer-02707", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-commandBuffer-02646", + "text": " commandBuffer must not be a protected command buffer" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-SampledType-04470", + "text": " If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-SampledType-04471", + "text": " If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-SampledType-04472", + "text": " If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-SampledType-04473", + "text": " If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-sparseImageInt64Atomics-04474", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-sparseImageInt64Atomics-04475", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + } + ], + "(VK_EXT_transform_feedback)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-maxMultiviewInstanceIndex-02688", + "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-sampleLocationsEnable-02689", + "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-viewportCount-03417", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the VkPipelineViewportStateCreateInfo::scissorCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-scissorCount-03418", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the scissorCount parameter of vkCmdSetScissorWithCountEXT must match the VkPipelineViewportStateCreateInfo::viewportCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-viewportCount-03419", + "text": " If the bound graphics pipeline state was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic states enabled then both vkCmdSetViewportWithCountEXT and vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the scissorCount parameter of vkCmdSetScissorWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-primitiveTopology-03420", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT dynamic state enabled then vkCmdSetPrimitiveTopologyEXT must have been called in the current command buffer prior to this drawing command, and the primitiveTopology parameter of vkCmdSetPrimitiveTopologyEXT must be of the same topology class as the pipeline VkPipelineInputAssemblyStateCreateInfo::topology state" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-viewportCount-04137", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportWScalingStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-viewportCount-04138", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-viewportCount-04139", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportShadingRateImageStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-viewportCount-04140", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-VkPipelineVieportCreateInfo-04141", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportSwizzleStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-VkPipelineVieportCreateInfo-04142", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportExclusiveScissorStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportExclusiveScissorStateCreateInfoNV::exclusiveScissorCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-04876", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT dynamic state enabled then vkCmdSetRasterizerDiscardEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-04877", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT dynamic state enabled then vkCmdSetDepthBiasEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-logicOp-04878", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-04875", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT dynamic state enabled then vkCmdSetPatchControlPointsEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-04879", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-primitiveFragmentShadingRateWithMultipleViewports-04552", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must be 1" + } + ], + "(VK_EXT_transform_feedback)+(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-imageView-06172", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-imageView-06173", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-viewMask-06178", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::viewMask equal to VkRenderingInfoKHR::viewMask" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-colorAttachmentCount-06179", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::colorAttachmentCount equal to VkRenderingInfoKHR::colorAttachmentCount" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-colorAttachmentCount-06180", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::colorAttachmentCount greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a VkFormat equal to the corresponding element of VkPipelineRenderingCreateInfoKHR::pColorAttachmentFormats used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-pDepthAttachment-06181", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::depthAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-pStencilAttachment-06182", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::stencilAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + } + ], + "(VK_EXT_transform_feedback)+(VK_KHR_dynamic_rendering)+(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-imageView-06174", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-imageView-06175", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_EXT_transform_feedback)+(VK_KHR_dynamic_rendering)+(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-imageView-06176", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-imageView-06177", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_EXT_transform_feedback)+(VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-imageView-06183", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentShadingRateAttachmentInfoKHR::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" + } + ], + "(VK_EXT_transform_feedback)+(VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-imageView-06184", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentDensityMapAttachmentInfoEXT::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT" + } + ], + "(VK_EXT_transform_feedback)+(VK_KHR_dynamic_rendering)+(VK_AMD_mixed_attachment_samples,VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-colorAttachmentCount-06185", + "text": " If the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the corresponding element of the pColorAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-pDepthAttachment-06186", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-pStencilAttachment-06187", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-colorAttachmentCount-06188", + "text": " If the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-pDepthAttachment-06189", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-pStencilAttachment-06190", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-renderPass-06198", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline must have been created with a VkGraphicsPipelineCreateInfo::renderPass equal to VK_NULL_HANDLE" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state)+(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-04912", + "text": " If the bound graphics pipeline was created with both the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT and VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic states enabled, then vkCmdSetVertexInputEXT must have been called in the current command buffer prior to this draw command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-pStrides-04913", + "text": " If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state)+!(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-pStrides-04884", + "text": " If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called in the current command buffer prior to this drawing command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-04914", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdSetVertexInputEXT must have been called in the current command buffer prior to this draw command" + } + ], + "(VK_EXT_transform_feedback)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-stage-06481", + "text": " The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of an element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_TASK_BIT_NV or VK_SHADER_STAGE_MESH_BIT_NV" + } + ] + }, + "vkCmdBeginConditionalRenderingEXT": { + "(VK_EXT_conditional_rendering)": [ + { + "vuid": "VUID-vkCmdBeginConditionalRenderingEXT-None-01980", + "text": " Conditional rendering must not already be active" + } + ] + }, + "VkConditionalRenderingBeginInfoEXT": { + "(VK_EXT_conditional_rendering)": [ + { + "vuid": "VUID-VkConditionalRenderingBeginInfoEXT-buffer-01981", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkConditionalRenderingBeginInfoEXT-buffer-01982", + "text": " buffer must have been created with the VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT bit set" + }, + { + "vuid": "VUID-VkConditionalRenderingBeginInfoEXT-offset-01983", + "text": " offset must be less than the size of buffer by at least 32 bits" + }, + { + "vuid": "VUID-VkConditionalRenderingBeginInfoEXT-offset-01984", + "text": " offset must be a multiple of 4" + } + ] + }, + "vkCmdEndConditionalRenderingEXT": { + "(VK_EXT_conditional_rendering)": [ + { + "vuid": "VUID-vkCmdEndConditionalRenderingEXT-None-01985", + "text": " Conditional rendering must be active" + }, + { + "vuid": "VUID-vkCmdEndConditionalRenderingEXT-None-01986", + "text": " If conditional rendering was made active outside of a render pass instance, it must not be ended inside a render pass instance" + }, + { + "vuid": "VUID-vkCmdEndConditionalRenderingEXT-None-01987", + "text": " If conditional rendering was made active within a subpass it must be ended in the same subpass" + } + ] + }, + "vkCmdDrawMeshTasksNV": { + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-magFilter-04553", + "text": " If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-mipmapMode-04770", + "text": " If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02691", + "text": " If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02699", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-commandBuffer-02701", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the VK_NV_inherited_viewport_scissor extension is enabled) for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02705", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02706", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-04115", + "text": " If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-OpImageWrite-04469", + "text": " If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-renderPass-02684", + "text": " The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-subpass-02685", + "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02686", + "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-04584", + "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command, except for cases involving read-only access to depth/stencil attachments as described in the Render Pass chapter" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-blendEnable-04727", + "text": " If rasterization is not disabled in the bound graphics pipeline, then for each color attachment in the subpass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the blendEnable member of the corresponding element of the pAttachments member of pColorBlendState must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-rasterizationSamples-04740", + "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then VkPipelineMultisampleStateCreateInfo::rasterizationSamples must be the same as the current subpass color and/or depth/stencil attachments" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-taskCount-02119", + "text": " taskCount must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxDrawMeshTasksCount" + } + ], + "(VK_NV_mesh_shader)+!(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-aspectMask-06478", + "text": " If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT." + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-06479", + "text": " If a VkImageView is sampled with depth comparison, the image view’s format features must contain VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-OpTypeImage-06423", + "text": " Any VkImageView or VkBufferView being written as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-OpTypeImage-06424", + "text": " Any VkImageView or VkBufferView being read as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR" + } + ], + "(VK_NV_mesh_shader)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02692", + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + } + ], + "(VK_NV_mesh_shader)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+!(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02693", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_NV_mesh_shader)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-filterCubic-02694", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-filterCubicMinmax-02695", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2" + } + ], + "(VK_NV_mesh_shader)+(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-flags-02696", + "text": " Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE" + } + ], + "(VK_NV_mesh_shader)+!(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02698", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-maintenance4-06425", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_mesh_shader)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-commandBuffer-02707", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-SampledType-04470", + "text": " If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-SampledType-04471", + "text": " If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-SampledType-04472", + "text": " If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-SampledType-04473", + "text": " If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-sparseImageInt64Atomics-04474", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-sparseImageInt64Atomics-04475", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + } + ], + "(VK_NV_mesh_shader)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-maxMultiviewInstanceIndex-02688", + "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-sampleLocationsEnable-02689", + "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-viewportCount-03417", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the VkPipelineViewportStateCreateInfo::scissorCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-scissorCount-03418", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the scissorCount parameter of vkCmdSetScissorWithCountEXT must match the VkPipelineViewportStateCreateInfo::viewportCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-viewportCount-03419", + "text": " If the bound graphics pipeline state was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic states enabled then both vkCmdSetViewportWithCountEXT and vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the scissorCount parameter of vkCmdSetScissorWithCountEXT" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-viewportCount-04137", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportWScalingStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-viewportCount-04138", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-viewportCount-04139", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportShadingRateImageStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-viewportCount-04140", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-VkPipelineVieportCreateInfo-04141", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportSwizzleStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-VkPipelineVieportCreateInfo-04142", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportExclusiveScissorStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportExclusiveScissorStateCreateInfoNV::exclusiveScissorCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-04876", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT dynamic state enabled then vkCmdSetRasterizerDiscardEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-04877", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT dynamic state enabled then vkCmdSetDepthBiasEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-logicOp-04878", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-primitiveFragmentShadingRateWithMultipleViewports-04552", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must be 1" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-imageView-06172", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-imageView-06173", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-viewMask-06178", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::viewMask equal to VkRenderingInfoKHR::viewMask" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-colorAttachmentCount-06179", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::colorAttachmentCount equal to VkRenderingInfoKHR::colorAttachmentCount" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-colorAttachmentCount-06180", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::colorAttachmentCount greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a VkFormat equal to the corresponding element of VkPipelineRenderingCreateInfoKHR::pColorAttachmentFormats used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-pDepthAttachment-06181", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::depthAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-pStencilAttachment-06182", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::stencilAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_dynamic_rendering)+(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-imageView-06174", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-imageView-06175", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_dynamic_rendering)+(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-imageView-06176", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-imageView-06177", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-imageView-06183", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentShadingRateAttachmentInfoKHR::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-imageView-06184", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentDensityMapAttachmentInfoEXT::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_dynamic_rendering)+(VK_AMD_mixed_attachment_samples,VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-colorAttachmentCount-06185", + "text": " If the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the corresponding element of the pColorAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-pDepthAttachment-06186", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-pStencilAttachment-06187", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-colorAttachmentCount-06188", + "text": " If the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-pDepthAttachment-06189", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-pStencilAttachment-06190", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-renderPass-06198", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline must have been created with a VkGraphicsPipelineCreateInfo::renderPass equal to VK_NULL_HANDLE" + } + ], + "(VK_NV_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-stage-06480", + "text": " The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of an element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT" + } + ] + }, + "vkCmdDrawMeshTasksIndirectNV": { + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-magFilter-04553", + "text": " If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-mipmapMode-04770", + "text": " If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02691", + "text": " If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02699", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-02701", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the VK_NV_inherited_viewport_scissor extension is enabled) for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02705", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02706", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-04115", + "text": " If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-OpImageWrite-04469", + "text": " If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-renderPass-02684", + "text": " The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-subpass-02685", + "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02686", + "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-04584", + "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command, except for cases involving read-only access to depth/stencil attachments as described in the Render Pass chapter" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-blendEnable-04727", + "text": " If rasterization is not disabled in the bound graphics pipeline, then for each color attachment in the subpass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the blendEnable member of the corresponding element of the pAttachments member of pColorBlendState must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-rasterizationSamples-04740", + "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then VkPipelineMultisampleStateCreateInfo::rasterizationSamples must be the same as the current subpass color and/or depth/stencil attachments" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-buffer-02708", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-buffer-02709", + "text": " buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-offset-02710", + "text": " offset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02718", + "text": " If the multi-draw indirect feature is not enabled, drawCount must be 0 or 1" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02719", + "text": " drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02146", + "text": " If drawCount is greater than 1, stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawMeshTasksIndirectCommandNV)" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02156", + "text": " If drawCount is equal to 1, (offset + sizeof(VkDrawMeshTasksIndirectCommandNV)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02157", + "text": " If drawCount is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawMeshTasksIndirectCommandNV)) must be less than or equal to the size of buffer" + } + ], + "(VK_NV_mesh_shader)+!(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-aspectMask-06478", + "text": " If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT." + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-06479", + "text": " If a VkImageView is sampled with depth comparison, the image view’s format features must contain VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-OpTypeImage-06423", + "text": " Any VkImageView or VkBufferView being written as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-OpTypeImage-06424", + "text": " Any VkImageView or VkBufferView being read as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR" + } + ], + "(VK_NV_mesh_shader)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02692", + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + } + ], + "(VK_NV_mesh_shader)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+!(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02693", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_NV_mesh_shader)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-filterCubic-02694", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-filterCubicMinmax-02695", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2" + } + ], + "(VK_NV_mesh_shader)+(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-flags-02696", + "text": " Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE" + } + ], + "(VK_NV_mesh_shader)+!(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02698", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-maintenance4-06425", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_mesh_shader)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-02707", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-02711", + "text": " commandBuffer must not be a protected command buffer" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-SampledType-04470", + "text": " If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-SampledType-04471", + "text": " If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-SampledType-04472", + "text": " If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-SampledType-04473", + "text": " If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-sparseImageInt64Atomics-04474", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-sparseImageInt64Atomics-04475", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + } + ], + "(VK_NV_mesh_shader)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-maxMultiviewInstanceIndex-02688", + "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-sampleLocationsEnable-02689", + "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-viewportCount-03417", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the VkPipelineViewportStateCreateInfo::scissorCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-scissorCount-03418", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the scissorCount parameter of vkCmdSetScissorWithCountEXT must match the VkPipelineViewportStateCreateInfo::viewportCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-viewportCount-03419", + "text": " If the bound graphics pipeline state was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic states enabled then both vkCmdSetViewportWithCountEXT and vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the scissorCount parameter of vkCmdSetScissorWithCountEXT" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-viewportCount-04137", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportWScalingStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-viewportCount-04138", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-viewportCount-04139", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportShadingRateImageStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-viewportCount-04140", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-VkPipelineVieportCreateInfo-04141", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportSwizzleStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-VkPipelineVieportCreateInfo-04142", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportExclusiveScissorStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportExclusiveScissorStateCreateInfoNV::exclusiveScissorCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-04876", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT dynamic state enabled then vkCmdSetRasterizerDiscardEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-04877", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT dynamic state enabled then vkCmdSetDepthBiasEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-logicOp-04878", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-primitiveFragmentShadingRateWithMultipleViewports-04552", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must be 1" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-imageView-06172", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-imageView-06173", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-viewMask-06178", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::viewMask equal to VkRenderingInfoKHR::viewMask" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-colorAttachmentCount-06179", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::colorAttachmentCount equal to VkRenderingInfoKHR::colorAttachmentCount" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-colorAttachmentCount-06180", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::colorAttachmentCount greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a VkFormat equal to the corresponding element of VkPipelineRenderingCreateInfoKHR::pColorAttachmentFormats used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-pDepthAttachment-06181", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::depthAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-pStencilAttachment-06182", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::stencilAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_dynamic_rendering)+(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-imageView-06174", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-imageView-06175", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_dynamic_rendering)+(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-imageView-06176", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-imageView-06177", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-imageView-06183", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentShadingRateAttachmentInfoKHR::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-imageView-06184", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentDensityMapAttachmentInfoEXT::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_dynamic_rendering)+(VK_AMD_mixed_attachment_samples,VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-colorAttachmentCount-06185", + "text": " If the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the corresponding element of the pColorAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-pDepthAttachment-06186", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-pStencilAttachment-06187", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-colorAttachmentCount-06188", + "text": " If the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-pDepthAttachment-06189", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-pStencilAttachment-06190", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-renderPass-06198", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline must have been created with a VkGraphicsPipelineCreateInfo::renderPass equal to VK_NULL_HANDLE" + } + ], + "(VK_NV_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-stage-06480", + "text": " The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of an element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT" + } + ] + }, + "VkDrawMeshTasksIndirectCommandNV": { + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-VkDrawMeshTasksIndirectCommandNV-taskCount-02175", + "text": " taskCount must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxDrawMeshTasksCount" + } + ] + }, + "vkCmdDrawMeshTasksIndirectCountNV": { + "(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-magFilter-04553", + "text": " If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-mipmapMode-04770", + "text": " If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02691", + "text": " If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02699", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-02701", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the VK_NV_inherited_viewport_scissor extension is enabled) for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02705", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02706", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-04115", + "text": " If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-OpImageWrite-04469", + "text": " If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-renderPass-02684", + "text": " The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-subpass-02685", + "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02686", + "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-04584", + "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command, except for cases involving read-only access to depth/stencil attachments as described in the Render Pass chapter" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-blendEnable-04727", + "text": " If rasterization is not disabled in the bound graphics pipeline, then for each color attachment in the subpass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the blendEnable member of the corresponding element of the pAttachments member of pColorBlendState must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-rasterizationSamples-04740", + "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then VkPipelineMultisampleStateCreateInfo::rasterizationSamples must be the same as the current subpass color and/or depth/stencil attachments" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-buffer-02708", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-buffer-02709", + "text": " buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-offset-02710", + "text": " offset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-countBuffer-02714", + "text": " If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-countBuffer-02715", + "text": " countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-countBufferOffset-02716", + "text": " countBufferOffset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-countBuffer-02717", + "text": " The count stored in countBuffer must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-countBufferOffset-04129", + "text": " (countBufferOffset + sizeof(uint32_t)) must be less than or equal to the size of countBuffer" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-stride-02182", + "text": " stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawMeshTasksIndirectCommandNV)" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-maxDrawCount-02183", + "text": " If maxDrawCount is greater than or equal to 1, (stride {times} (maxDrawCount - 1) + offset + sizeof(VkDrawMeshTasksIndirectCommandNV)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-countBuffer-02191", + "text": " If the count stored in countBuffer is equal to 1, (offset + sizeof(VkDrawMeshTasksIndirectCommandNV)) must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-countBuffer-02192", + "text": " If the count stored in countBuffer is greater than 1, (stride {times} (drawCount - 1) + offset + sizeof(VkDrawMeshTasksIndirectCommandNV)) must be less than or equal to the size of buffer" + } + ], + "(VK_NV_mesh_shader)+!(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-aspectMask-06478", + "text": " If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT." + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-06479", + "text": " If a VkImageView is sampled with depth comparison, the image view’s format features must contain VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-OpTypeImage-06423", + "text": " Any VkImageView or VkBufferView being written as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-OpTypeImage-06424", + "text": " Any VkImageView or VkBufferView being read as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR" + } + ], + "(VK_NV_mesh_shader)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02692", + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + } + ], + "(VK_NV_mesh_shader)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+!(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02693", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_NV_mesh_shader)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-filterCubic-02694", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-filterCubicMinmax-02695", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2" + } + ], + "(VK_NV_mesh_shader)+(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-flags-02696", + "text": " Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE" + } + ], + "(VK_NV_mesh_shader)+!(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02698", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-maintenance4-06425", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_mesh_shader)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-02707", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-02711", + "text": " commandBuffer must not be a protected command buffer" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-SampledType-04470", + "text": " If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-SampledType-04471", + "text": " If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-SampledType-04472", + "text": " If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-SampledType-04473", + "text": " If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-sparseImageInt64Atomics-04474", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-sparseImageInt64Atomics-04475", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + } + ], + "(VK_NV_mesh_shader)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-maxMultiviewInstanceIndex-02688", + "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-sampleLocationsEnable-02689", + "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-viewportCount-03417", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the VkPipelineViewportStateCreateInfo::scissorCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-scissorCount-03418", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the scissorCount parameter of vkCmdSetScissorWithCountEXT must match the VkPipelineViewportStateCreateInfo::viewportCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-viewportCount-03419", + "text": " If the bound graphics pipeline state was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic states enabled then both vkCmdSetViewportWithCountEXT and vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the scissorCount parameter of vkCmdSetScissorWithCountEXT" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-viewportCount-04137", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportWScalingStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-viewportCount-04138", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-viewportCount-04139", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportShadingRateImageStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-viewportCount-04140", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-VkPipelineVieportCreateInfo-04141", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportSwizzleStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-VkPipelineVieportCreateInfo-04142", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportExclusiveScissorStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportExclusiveScissorStateCreateInfoNV::exclusiveScissorCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-04876", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT dynamic state enabled then vkCmdSetRasterizerDiscardEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-04877", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT dynamic state enabled then vkCmdSetDepthBiasEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-logicOp-04878", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-primitiveFragmentShadingRateWithMultipleViewports-04552", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must be 1" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-imageView-06172", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-imageView-06173", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-viewMask-06178", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::viewMask equal to VkRenderingInfoKHR::viewMask" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-colorAttachmentCount-06179", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::colorAttachmentCount equal to VkRenderingInfoKHR::colorAttachmentCount" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-colorAttachmentCount-06180", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::colorAttachmentCount greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a VkFormat equal to the corresponding element of VkPipelineRenderingCreateInfoKHR::pColorAttachmentFormats used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-pDepthAttachment-06181", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::depthAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-pStencilAttachment-06182", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::stencilAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_dynamic_rendering)+(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-imageView-06174", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-imageView-06175", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_dynamic_rendering)+(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-imageView-06176", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-imageView-06177", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-imageView-06183", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentShadingRateAttachmentInfoKHR::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-imageView-06184", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentDensityMapAttachmentInfoEXT::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT" + } + ], + "(VK_NV_mesh_shader)+(VK_KHR_dynamic_rendering)+(VK_AMD_mixed_attachment_samples,VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-colorAttachmentCount-06185", + "text": " If the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the corresponding element of the pColorAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-pDepthAttachment-06186", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-pStencilAttachment-06187", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-colorAttachmentCount-06188", + "text": " If the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-pDepthAttachment-06189", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-pStencilAttachment-06190", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-renderPass-06198", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline must have been created with a VkGraphicsPipelineCreateInfo::renderPass equal to VK_NULL_HANDLE" + } + ], + "(VK_NV_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-stage-06480", + "text": " The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of an element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT" + } + ], + "(VK_NV_mesh_shader)+(VK_VERSION_1_2)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-04445", + "text": " If drawIndirectCount is not enabled this function must not be used" + } + ] + }, + "VkPipelineVertexInputStateCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-vertexBindingDescriptionCount-00613", + "text": " vertexBindingDescriptionCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings" + }, + { + "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-vertexAttributeDescriptionCount-00614", + "text": " vertexAttributeDescriptionCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputAttributes" + }, + { + "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-binding-00615", + "text": " For every binding specified by each element of pVertexAttributeDescriptions, a VkVertexInputBindingDescription must exist in pVertexBindingDescriptions with the same value of binding" + }, + { + "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-00616", + "text": " All elements of pVertexBindingDescriptions must describe distinct binding numbers" + }, + { + "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-00617", + "text": " All elements of pVertexAttributeDescriptions must describe distinct attribute locations" + }, + { + "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkPipelineVertexInputDivisorStateCreateInfoEXT" + }, + { + "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-parameter", + "text": " If vertexBindingDescriptionCount is not 0, pVertexBindingDescriptions must be a valid pointer to an array of vertexBindingDescriptionCount valid VkVertexInputBindingDescription structures" + }, + { + "vuid": "VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-parameter", + "text": " If vertexAttributeDescriptionCount is not 0, pVertexAttributeDescriptions must be a valid pointer to an array of vertexAttributeDescriptionCount valid VkVertexInputAttributeDescription structures" + } + ] + }, + "VkVertexInputBindingDescription": { + "core": [ + { + "vuid": "VUID-VkVertexInputBindingDescription-binding-00618", + "text": " binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings" + }, + { + "vuid": "VUID-VkVertexInputBindingDescription-stride-00619", + "text": " stride must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindingStride" + }, + { + "vuid": "VUID-VkVertexInputBindingDescription-inputRate-parameter", + "text": " inputRate must be a valid VkVertexInputRate value" + } + ], + "(VK_KHR_portability_subset)": [ + { + "vuid": "VUID-VkVertexInputBindingDescription-stride-04456", + "text": " If the VK_KHR_portability_subset extension is enabled, stride must be a multiple of, and at least as large as, VkPhysicalDevicePortabilitySubsetPropertiesKHR::minVertexInputBindingStrideAlignment" + } + ] + }, + "VkVertexInputAttributeDescription": { + "core": [ + { + "vuid": "VUID-VkVertexInputAttributeDescription-location-00620", + "text": " location must be less than VkPhysicalDeviceLimits::maxVertexInputAttributes" + }, + { + "vuid": "VUID-VkVertexInputAttributeDescription-binding-00621", + "text": " binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings" + }, + { + "vuid": "VUID-VkVertexInputAttributeDescription-offset-00622", + "text": " offset must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputAttributeOffset" + }, + { + "vuid": "VUID-VkVertexInputAttributeDescription-format-00623", + "text": " format must be allowed as a vertex buffer format, as specified by the VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT flag in VkFormatProperties::bufferFeatures returned by vkGetPhysicalDeviceFormatProperties" + }, + { + "vuid": "VUID-VkVertexInputAttributeDescription-format-parameter", + "text": " format must be a valid VkFormat value" + } + ], + "(VK_KHR_portability_subset)": [ + { + "vuid": "VUID-VkVertexInputAttributeDescription-vertexAttributeAccessBeyondStride-04457", + "text": " If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::vertexAttributeAccessBeyondStride is VK_FALSE, the sum of offset plus the size of the vertex attribute data described by format must not be greater than stride in the VkVertexInputBindingDescription referenced in binding" + } + ] + }, + "vkCmdSetVertexInputEXT": { + "(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetVertexInputEXT-None-04790", + "text": " The vertexInputDynamicState feature must be enabled" + }, + { + "vuid": "VUID-vkCmdSetVertexInputEXT-vertexBindingDescriptionCount-04791", + "text": " vertexBindingDescriptionCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings" + }, + { + "vuid": "VUID-vkCmdSetVertexInputEXT-vertexAttributeDescriptionCount-04792", + "text": " vertexAttributeDescriptionCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputAttributes" + }, + { + "vuid": "VUID-vkCmdSetVertexInputEXT-binding-04793", + "text": " For every binding specified by each element of pVertexAttributeDescriptions, a VkVertexInputBindingDescription2EXT must exist in pVertexBindingDescriptions with the same value of binding" + }, + { + "vuid": "VUID-vkCmdSetVertexInputEXT-pVertexBindingDescriptions-04794", + "text": " All elements of pVertexBindingDescriptions must describe distinct binding numbers" + }, + { + "vuid": "VUID-vkCmdSetVertexInputEXT-pVertexAttributeDescriptions-04795", + "text": " All elements of pVertexAttributeDescriptions must describe distinct attribute locations" + }, + { + "vuid": "VUID-vkCmdSetVertexInputEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetVertexInputEXT-pVertexBindingDescriptions-parameter", + "text": " If vertexBindingDescriptionCount is not 0, pVertexBindingDescriptions must be a valid pointer to an array of vertexBindingDescriptionCount valid VkVertexInputBindingDescription2EXT structures" + }, + { + "vuid": "VUID-vkCmdSetVertexInputEXT-pVertexAttributeDescriptions-parameter", + "text": " If vertexAttributeDescriptionCount is not 0, pVertexAttributeDescriptions must be a valid pointer to an array of vertexAttributeDescriptionCount valid VkVertexInputAttributeDescription2EXT structures" + }, + { + "vuid": "VUID-vkCmdSetVertexInputEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetVertexInputEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "VkVertexInputBindingDescription2EXT": { + "(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-VkVertexInputBindingDescription2EXT-binding-04796", + "text": " binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings" + }, + { + "vuid": "VUID-VkVertexInputBindingDescription2EXT-stride-04797", + "text": " stride must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindingStride" + }, + { + "vuid": "VUID-VkVertexInputBindingDescription2EXT-divisor-04798", + "text": " If the vertexAttributeInstanceRateZeroDivisor feature is not enabled, divisor must not be 0" + }, + { + "vuid": "VUID-VkVertexInputBindingDescription2EXT-divisor-04799", + "text": " If the vertexAttributeInstanceRateDivisor feature is not enabled, divisor must be 1" + }, + { + "vuid": "VUID-VkVertexInputBindingDescription2EXT-divisor-06226", + "text": " divisor must be a value between 0 and VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::maxVertexAttribDivisor, inclusive" + }, + { + "vuid": "VUID-VkVertexInputBindingDescription2EXT-divisor-06227", + "text": " If divisor is not 1 then inputRate must be of type VK_VERTEX_INPUT_RATE_INSTANCE" + }, + { + "vuid": "VUID-VkVertexInputBindingDescription2EXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT" + }, + { + "vuid": "VUID-VkVertexInputBindingDescription2EXT-inputRate-parameter", + "text": " inputRate must be a valid VkVertexInputRate value" + } + ] + }, + "VkVertexInputAttributeDescription2EXT": { + "(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-VkVertexInputAttributeDescription2EXT-location-06228", + "text": " location must be less than VkPhysicalDeviceLimits::maxVertexInputAttributes" + }, + { + "vuid": "VUID-VkVertexInputAttributeDescription2EXT-binding-06229", + "text": " binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings" + }, + { + "vuid": "VUID-VkVertexInputAttributeDescription2EXT-offset-06230", + "text": " offset must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputAttributeOffset" + }, + { + "vuid": "VUID-VkVertexInputAttributeDescription2EXT-format-04805", + "text": " format must be allowed as a vertex buffer format, as specified by the VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT flag in VkFormatProperties::bufferFeatures returned by vkGetPhysicalDeviceFormatProperties" + }, + { + "vuid": "VUID-VkVertexInputAttributeDescription2EXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT" + }, + { + "vuid": "VUID-VkVertexInputAttributeDescription2EXT-format-parameter", + "text": " format must be a valid VkFormat value" + } + ], + "(VK_EXT_vertex_input_dynamic_state)+(VK_KHR_portability_subset)": [ + { + "vuid": "VUID-VkVertexInputAttributeDescription2EXT-vertexAttributeAccessBeyondStride-04806", + "text": " If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::vertexAttributeAccessBeyondStride is VK_FALSE, the sum of offset plus the size of the vertex attribute data described by format must not be greater than stride in the VkVertexInputBindingDescription2EXT referenced in binding" + } + ] + }, + "vkCmdBindVertexBuffers": { + "core": [ + { + "vuid": "VUID-vkCmdBindVertexBuffers-firstBinding-00624", + "text": " firstBinding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-firstBinding-00625", + "text": " The sum of firstBinding and bindingCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-pOffsets-00626", + "text": " All elements of pOffsets must be less than the size of the corresponding element in pBuffers" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-pBuffers-00627", + "text": " All elements of pBuffers must have been created with the VK_BUFFER_USAGE_VERTEX_BUFFER_BIT flag" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-pBuffers-00628", + "text": " Each element of pBuffers that is non-sparse must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-pBuffers-04001", + "text": " If the nullDescriptor feature is not enabled, all elements of pBuffers must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-pBuffers-parameter", + "text": " pBuffers must be a valid pointer to an array of bindingCount valid or VK_NULL_HANDLE VkBuffer handles" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-pOffsets-parameter", + "text": " pOffsets must be a valid pointer to an array of bindingCount VkDeviceSize values" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-bindingCount-arraylength", + "text": " bindingCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers-commonparent", + "text": " Both of commandBuffer, and the elements of pBuffers that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_EXT_robustness2)": [ + { + "vuid": "VUID-vkCmdBindVertexBuffers-pBuffers-04002", + "text": " If an element of pBuffers is VK_NULL_HANDLE, then the corresponding element of pOffsets must be zero" + } + ] + }, + "vkCmdBindVertexBuffers2EXT": { + "(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdBindVertexBuffers2EXT-firstBinding-03355", + "text": " firstBinding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers2EXT-firstBinding-03356", + "text": " The sum of firstBinding and bindingCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers2EXT-pOffsets-03357", + "text": " All elements of pOffsets must be less than the size of the corresponding element in pBuffers" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers2EXT-pSizes-03358", + "text": " If pSizes is not NULL, all elements of pOffsets plus pSizes must be less than or equal to the size of the corresponding element in pBuffers" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers2EXT-pBuffers-03359", + "text": " All elements of pBuffers must have been created with the VK_BUFFER_USAGE_VERTEX_BUFFER_BIT flag" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers2EXT-pBuffers-03360", + "text": " Each element of pBuffers that is non-sparse must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers2EXT-pBuffers-04111", + "text": " If the nullDescriptor feature is not enabled, all elements of pBuffers must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers2EXT-pStrides-03362", + "text": " If pStrides is not NULL each element of pStrides must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindingStride" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers2EXT-pStrides-06209", + "text": " If pStrides is not NULL each element of pStrides must be either 0 or greater than or equal to the maximum extent of all vertex input attributes fetched from the corresponding binding, where the extent is calculated as the VkVertexInputAttributeDescription::offset plus VkVertexInputAttributeDescription::format size" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers2EXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers2EXT-pBuffers-parameter", + "text": " pBuffers must be a valid pointer to an array of bindingCount valid or VK_NULL_HANDLE VkBuffer handles" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers2EXT-pOffsets-parameter", + "text": " pOffsets must be a valid pointer to an array of bindingCount VkDeviceSize values" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers2EXT-pSizes-parameter", + "text": " If pSizes is not NULL, pSizes must be a valid pointer to an array of bindingCount VkDeviceSize values" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers2EXT-pStrides-parameter", + "text": " If pStrides is not NULL, pStrides must be a valid pointer to an array of bindingCount VkDeviceSize values" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers2EXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers2EXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers2EXT-bindingCount-arraylength", + "text": " If any of pSizes, or pStrides are not NULL, bindingCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdBindVertexBuffers2EXT-commonparent", + "text": " Both of commandBuffer, and the elements of pBuffers that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_EXT_robustness2)": [ + { + "vuid": "VUID-vkCmdBindVertexBuffers2EXT-pBuffers-04112", + "text": " If an element of pBuffers is VK_NULL_HANDLE, then the corresponding element of pOffsets must be zero" + } + ] + }, + "VkPipelineVertexInputDivisorStateCreateInfoEXT": { + "(VK_EXT_vertex_attribute_divisor)": [ + { + "vuid": "VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-pVertexBindingDivisors-parameter", + "text": " pVertexBindingDivisors must be a valid pointer to an array of vertexBindingDivisorCount VkVertexInputBindingDivisorDescriptionEXT structures" + }, + { + "vuid": "VUID-VkPipelineVertexInputDivisorStateCreateInfoEXT-vertexBindingDivisorCount-arraylength", + "text": " vertexBindingDivisorCount must be greater than 0" + } + ] + }, + "VkVertexInputBindingDivisorDescriptionEXT": { + "(VK_EXT_vertex_attribute_divisor)": [ + { + "vuid": "VUID-VkVertexInputBindingDivisorDescriptionEXT-binding-01869", + "text": " binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings" + }, + { + "vuid": "VUID-VkVertexInputBindingDivisorDescriptionEXT-vertexAttributeInstanceRateZeroDivisor-02228", + "text": " If the vertexAttributeInstanceRateZeroDivisor feature is not enabled, divisor must not be 0" + }, + { + "vuid": "VUID-VkVertexInputBindingDivisorDescriptionEXT-vertexAttributeInstanceRateDivisor-02229", + "text": " If the vertexAttributeInstanceRateDivisor feature is not enabled, divisor must be 1" + }, + { + "vuid": "VUID-VkVertexInputBindingDivisorDescriptionEXT-divisor-01870", + "text": " divisor must be a value between 0 and VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::maxVertexAttribDivisor, inclusive" + }, + { + "vuid": "VUID-VkVertexInputBindingDivisorDescriptionEXT-inputRate-01871", + "text": " VkVertexInputBindingDescription::inputRate must be of type VK_VERTEX_INPUT_RATE_INSTANCE for this binding" + } + ] + }, + "VkPipelineTessellationStateCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineTessellationStateCreateInfo-patchControlPoints-01214", + "text": " patchControlPoints must be greater than zero and less than or equal to VkPhysicalDeviceLimits::maxTessellationPatchSize" + }, + { + "vuid": "VUID-VkPipelineTessellationStateCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineTessellationStateCreateInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkPipelineTessellationDomainOriginStateCreateInfo" + }, + { + "vuid": "VUID-VkPipelineTessellationStateCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkPipelineTessellationStateCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + } + ] + }, + "VkPipelineTessellationDomainOriginStateCreateInfo": { + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkPipelineTessellationDomainOriginStateCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineTessellationDomainOriginStateCreateInfo-domainOrigin-parameter", + "text": " domainOrigin must be a valid VkTessellationDomainOrigin value" + } + ] + }, + "vkCmdBindTransformFeedbackBuffersEXT": { + "(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdBindTransformFeedbackBuffersEXT-transformFeedback-02355", + "text": " VkPhysicalDeviceTransformFeedbackFeaturesEXT::transformFeedback must be enabled" + }, + { + "vuid": "VUID-vkCmdBindTransformFeedbackBuffersEXT-firstBinding-02356", + "text": " firstBinding must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBuffers" + }, + { + "vuid": "VUID-vkCmdBindTransformFeedbackBuffersEXT-firstBinding-02357", + "text": " The sum of firstBinding and bindingCount must be less than or equal to VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBuffers" + }, + { + "vuid": "VUID-vkCmdBindTransformFeedbackBuffersEXT-pOffsets-02358", + "text": " All elements of pOffsets must be less than the size of the corresponding element in pBuffers" + }, + { + "vuid": "VUID-vkCmdBindTransformFeedbackBuffersEXT-pOffsets-02359", + "text": " All elements of pOffsets must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdBindTransformFeedbackBuffersEXT-pBuffers-02360", + "text": " All elements of pBuffers must have been created with the VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT flag" + }, + { + "vuid": "VUID-vkCmdBindTransformFeedbackBuffersEXT-pSize-02361", + "text": " If the optional pSize array is specified, each element of pSizes must either be VK_WHOLE_SIZE, or be less than or equal to VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBufferSize" + }, + { + "vuid": "VUID-vkCmdBindTransformFeedbackBuffersEXT-pSizes-02362", + "text": " All elements of pSizes must be either VK_WHOLE_SIZE, or less than or equal to the size of the corresponding buffer in pBuffers" + }, + { + "vuid": "VUID-vkCmdBindTransformFeedbackBuffersEXT-pOffsets-02363", + "text": " All elements of pOffsets plus pSizes, where the pSizes, element is not VK_WHOLE_SIZE, must be less than or equal to the size of the corresponding buffer in pBuffers" + }, + { + "vuid": "VUID-vkCmdBindTransformFeedbackBuffersEXT-pBuffers-02364", + "text": " Each element of pBuffers that is non-sparse must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBindTransformFeedbackBuffersEXT-None-02365", + "text": " Transform feedback must not be active when the vkCmdBindTransformFeedbackBuffersEXT command is recorded" + } + ] + }, + "vkCmdBeginTransformFeedbackEXT": { + "(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdBeginTransformFeedbackEXT-transformFeedback-02366", + "text": " VkPhysicalDeviceTransformFeedbackFeaturesEXT::transformFeedback must be enabled" + }, + { + "vuid": "VUID-vkCmdBeginTransformFeedbackEXT-None-02367", + "text": " Transform feedback must not be active" + }, + { + "vuid": "VUID-vkCmdBeginTransformFeedbackEXT-firstCounterBuffer-02368", + "text": " firstCounterBuffer must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBuffers" + }, + { + "vuid": "VUID-vkCmdBeginTransformFeedbackEXT-firstCounterBuffer-02369", + "text": " The sum of firstCounterBuffer and counterBufferCount must be less than or equal to VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBuffers" + }, + { + "vuid": "VUID-vkCmdBeginTransformFeedbackEXT-counterBufferCount-02607", + "text": " If counterBufferCount is not 0, and pCounterBuffers is not NULL, pCounterBuffers must be a valid pointer to an array of counterBufferCount VkBuffer handles that are either valid or VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdBeginTransformFeedbackEXT-pCounterBufferOffsets-02370", + "text": " For each buffer handle in the array, if it is not VK_NULL_HANDLE it must reference a buffer large enough to hold 4 bytes at the corresponding offset from the pCounterBufferOffsets array" + }, + { + "vuid": "VUID-vkCmdBeginTransformFeedbackEXT-pCounterBuffer-02371", + "text": " If pCounterBuffer is NULL, then pCounterBufferOffsets must also be NULL" + }, + { + "vuid": "VUID-vkCmdBeginTransformFeedbackEXT-pCounterBuffers-02372", + "text": " For each buffer handle in the pCounterBuffers array that is not VK_NULL_HANDLE it must have been created with a usage value containing VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdBeginTransformFeedbackEXT-None-06233", + "text": " A valid graphics pipeline must be bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdBeginTransformFeedbackEXT-None-04128", + "text": " The last pre-rasterization shader stage of the bound graphics pipeline must have been declared with the Xfb execution mode" + } + ], + "(VK_EXT_transform_feedback)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdBeginTransformFeedbackEXT-None-02373", + "text": " Transform feedback must not be made active in a render pass instance with multiview enabled" + } + ] + }, + "vkCmdEndTransformFeedbackEXT": { + "(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdEndTransformFeedbackEXT-transformFeedback-02374", + "text": " VkPhysicalDeviceTransformFeedbackFeaturesEXT::transformFeedback must be enabled" + }, + { + "vuid": "VUID-vkCmdEndTransformFeedbackEXT-None-02375", + "text": " Transform feedback must be active" + }, + { + "vuid": "VUID-vkCmdEndTransformFeedbackEXT-firstCounterBuffer-02376", + "text": " firstCounterBuffer must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBuffers" + }, + { + "vuid": "VUID-vkCmdEndTransformFeedbackEXT-firstCounterBuffer-02377", + "text": " The sum of firstCounterBuffer and counterBufferCount must be less than or equal to VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBuffers" + }, + { + "vuid": "VUID-vkCmdEndTransformFeedbackEXT-counterBufferCount-02608", + "text": " If counterBufferCount is not 0, and pCounterBuffers is not NULL, pCounterBuffers must be a valid pointer to an array of counterBufferCount VkBuffer handles that are either valid or VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdEndTransformFeedbackEXT-pCounterBufferOffsets-02378", + "text": " For each buffer handle in the array, if it is not VK_NULL_HANDLE it must reference a buffer large enough to hold 4 bytes at the corresponding offset from the pCounterBufferOffsets array" + }, + { + "vuid": "VUID-vkCmdEndTransformFeedbackEXT-pCounterBuffer-02379", + "text": " If pCounterBuffer is NULL, then pCounterBufferOffsets must also be NULL" + }, + { + "vuid": "VUID-vkCmdEndTransformFeedbackEXT-pCounterBuffers-02380", + "text": " For each buffer handle in the pCounterBuffers array that is not VK_NULL_HANDLE it must have been created with a usage value containing VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT" + } + ] + }, + "VkPipelineViewportSwizzleStateCreateInfoNV": { + "(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-VkPipelineViewportSwizzleStateCreateInfoNV-viewportCount-01215", + "text": " viewportCount must be greater than or equal to the viewportCount set in VkPipelineViewportStateCreateInfo" + } + ] + }, + "VkPipelineRasterizationProvokingVertexStateCreateInfoEXT": { + "(VK_EXT_provoking_vertex)": [ + { + "vuid": "VUID-VkPipelineRasterizationProvokingVertexStateCreateInfoEXT-provokingVertexMode-04883", + "text": " If provokingVertexMode is VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT, then the provokingVertexLast feature must be enabled" + } + ] + }, + "VkPipelineViewportDepthClipControlCreateInfoEXT": { + "(VK_EXT_depth_clip_control)": [ + { + "vuid": "VUID-VkPipelineViewportDepthClipControlCreateInfoEXT-negativeOneToOne-06470", + "text": " If depthClipControl is not enabled, negativeOneToOne must be VK_FALSE" + } + ] + }, + "vkCmdSetViewportWScalingNV": { + "(VK_NV_clip_space_w_scaling)": [ + { + "vuid": "VUID-vkCmdSetViewportWScalingNV-firstViewport-01324", + "text": " The sum of firstViewport and viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive" + } + ] + }, + "VkPipelineViewportStateCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-viewportCount-01216", + "text": " If the multiple viewports feature is not enabled, viewportCount must not be greater than 1" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-scissorCount-01217", + "text": " If the multiple viewports feature is not enabled, scissorCount must not be greater than 1" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-viewportCount-01218", + "text": " viewportCount must be less than or equal to VkPhysicalDeviceLimits::maxViewports" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-scissorCount-01219", + "text": " scissorCount must be less than or equal to VkPhysicalDeviceLimits::maxViewports" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-x-02821", + "text": " The x and y members of offset member of any element of pScissors must be greater than or equal to 0" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-offset-02822", + "text": " Evaluation of (offset.x + extent.width) must not cause a signed integer addition overflow for any element of pScissors" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-offset-02823", + "text": " Evaluation of (offset.y + extent.height) must not cause a signed integer addition overflow for any element of pScissors" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + } + ], + "!(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-scissorCount-01220", + "text": " scissorCount and viewportCount must be identical" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-viewportCount-arraylength", + "text": " viewportCount must be greater than 0" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-scissorCount-arraylength", + "text": " scissorCount must be greater than 0" + } + ], + "(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-scissorCount-04134", + "text": " If the graphics pipeline is being created without VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT set then scissorCount and viewportCount must be identical" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-viewportCount-04135", + "text": " If the graphics pipeline is being created with VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT set then viewportCount must be 0, otherwise it must be greater than 0" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-scissorCount-04136", + "text": " If the graphics pipeline is being created with VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT set then scissorCount must be 0, otherwise it must be greater than 0" + } + ], + "(VK_NV_clip_space_w_scaling)": [ + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-viewportWScalingEnable-01726", + "text": " If the viewportWScalingEnable member of a VkPipelineViewportWScalingStateCreateInfoNV structure included in the pNext chain is VK_TRUE, the viewportCount member of the VkPipelineViewportWScalingStateCreateInfoNV structure must be greater than or equal to VkPipelineViewportStateCreateInfo::viewportCount" + } + ] + }, + "vkCmdSetViewportWithCountEXT": { + "(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetViewportWithCountEXT-None-03393", + "text": " The extendedDynamicState feature must be enabled" + }, + { + "vuid": "VUID-vkCmdSetViewportWithCountEXT-viewportCount-03394", + "text": " viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive" + }, + { + "vuid": "VUID-vkCmdSetViewportWithCountEXT-viewportCount-03395", + "text": " If the multiple viewports feature is not enabled, viewportCount must be 1" + }, + { + "vuid": "VUID-vkCmdSetViewportWithCountEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetViewportWithCountEXT-pViewports-parameter", + "text": " pViewports must be a valid pointer to an array of viewportCount valid VkViewport structures" + }, + { + "vuid": "VUID-vkCmdSetViewportWithCountEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetViewportWithCountEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdSetViewportWithCountEXT-viewportCount-arraylength", + "text": " viewportCount must be greater than 0" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_NV_inherited_viewport_scissor)": [ + { + "vuid": "VUID-vkCmdSetViewportWithCountEXT-commandBuffer-04819", + "text": " commandBuffer must not have VkCommandBufferInheritanceViewportScissorInfoNV::viewportScissor2D enabled" + } + ] + }, + "vkCmdSetScissorWithCountEXT": { + "(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetScissorWithCountEXT-None-03396", + "text": " The extendedDynamicState feature must be enabled" + }, + { + "vuid": "VUID-vkCmdSetScissorWithCountEXT-scissorCount-03397", + "text": " scissorCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive" + }, + { + "vuid": "VUID-vkCmdSetScissorWithCountEXT-scissorCount-03398", + "text": " If the multiple viewports feature is not enabled, scissorCount must be 1" + }, + { + "vuid": "VUID-vkCmdSetScissorWithCountEXT-x-03399", + "text": " The x and y members of offset member of any element of pScissors must be greater than or equal to 0" + }, + { + "vuid": "VUID-vkCmdSetScissorWithCountEXT-offset-03400", + "text": " Evaluation of (offset.x + extent.width) must not cause a signed integer addition overflow for any element of pScissors" + }, + { + "vuid": "VUID-vkCmdSetScissorWithCountEXT-offset-03401", + "text": " Evaluation of (offset.y + extent.height) must not cause a signed integer addition overflow for any element of pScissors" + }, + { + "vuid": "VUID-vkCmdSetScissorWithCountEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetScissorWithCountEXT-pScissors-parameter", + "text": " pScissors must be a valid pointer to an array of scissorCount VkRect2D structures" + }, + { + "vuid": "VUID-vkCmdSetScissorWithCountEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetScissorWithCountEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdSetScissorWithCountEXT-scissorCount-arraylength", + "text": " scissorCount must be greater than 0" + } + ], + "(VK_EXT_extended_dynamic_state)+(VK_NV_inherited_viewport_scissor)": [ + { + "vuid": "VUID-vkCmdSetScissorWithCountEXT-commandBuffer-04820", + "text": " commandBuffer must not have VkCommandBufferInheritanceViewportScissorInfoNV::viewportScissor2D enabled" + } + ] + }, + "vkCmdSetViewport": { + "core": [ + { + "vuid": "VUID-vkCmdSetViewport-firstViewport-01223", + "text": " The sum of firstViewport and viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive" + }, + { + "vuid": "VUID-vkCmdSetViewport-firstViewport-01224", + "text": " If the multiple viewports feature is not enabled, firstViewport must be 0" + }, + { + "vuid": "VUID-vkCmdSetViewport-viewportCount-01225", + "text": " If the multiple viewports feature is not enabled, viewportCount must be 1" + }, + { + "vuid": "VUID-vkCmdSetViewport-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetViewport-pViewports-parameter", + "text": " pViewports must be a valid pointer to an array of viewportCount valid VkViewport structures" + }, + { + "vuid": "VUID-vkCmdSetViewport-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetViewport-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdSetViewport-viewportCount-arraylength", + "text": " viewportCount must be greater than 0" + } + ], + "(VK_NV_inherited_viewport_scissor)": [ + { + "vuid": "VUID-vkCmdSetViewport-commandBuffer-04821", + "text": " commandBuffer must not have VkCommandBufferInheritanceViewportScissorInfoNV::viewportScissor2D enabled" + } + ] + }, + "VkViewport": { + "core": [ + { + "vuid": "VUID-VkViewport-width-01770", + "text": " width must be greater than 0.0" + }, + { + "vuid": "VUID-VkViewport-width-01771", + "text": " width must be less than or equal to VkPhysicalDeviceLimits::maxViewportDimensions[0]" + }, + { + "vuid": "VUID-VkViewport-height-01773", + "text": " The absolute value of height must be less than or equal to VkPhysicalDeviceLimits::maxViewportDimensions[1]" + }, + { + "vuid": "VUID-VkViewport-x-01774", + "text": " x must be greater than or equal to viewportBoundsRange[0]" + }, + { + "vuid": "VUID-VkViewport-x-01232", + "text": " (x + width) must be less than or equal to viewportBoundsRange[1]" + }, + { + "vuid": "VUID-VkViewport-y-01775", + "text": " y must be greater than or equal to viewportBoundsRange[0]" + }, + { + "vuid": "VUID-VkViewport-y-01233", + "text": " (y + height) must be less than or equal to viewportBoundsRange[1]" + } + ], + "!(VK_VERSION_1_1,VK_KHR_maintenance1,VK_AMD_negative_viewport_height)": [ + { + "vuid": "VUID-VkViewport-height-01772", + "text": " height must be greater than 0.0" + } + ], + "(VK_VERSION_1_1,VK_KHR_maintenance1,VK_AMD_negative_viewport_height)": [ + { + "vuid": "VUID-VkViewport-y-01776", + "text": " y must be less than or equal to viewportBoundsRange[1]" + }, + { + "vuid": "VUID-VkViewport-y-01777", + "text": " (y + height) must be greater than or equal to viewportBoundsRange[0]" + } + ], + "(VK_EXT_depth_range_unrestricted)": [ + { + "vuid": "VUID-VkViewport-minDepth-01234", + "text": " Unless VK_EXT_depth_range_unrestricted extension is enabled minDepth must be between 0.0 and 1.0, inclusive" + }, + { + "vuid": "VUID-VkViewport-maxDepth-01235", + "text": " Unless VK_EXT_depth_range_unrestricted extension is enabled maxDepth must be between 0.0 and 1.0, inclusive" + } + ], + "!(VK_EXT_depth_range_unrestricted)": [ + { + "vuid": "VUID-VkViewport-minDepth-02540", + "text": " minDepth must be between 0.0 and 1.0, inclusive" + }, + { + "vuid": "VUID-VkViewport-maxDepth-02541", + "text": " maxDepth must be between 0.0 and 1.0, inclusive" + } + ] + }, + "VkPipelineRasterizationStateCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-depthClampEnable-00782", + "text": " If the depth clamping feature is not enabled, depthClampEnable must be VK_FALSE" + }, + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineRasterizationConservativeStateCreateInfoEXT, VkPipelineRasterizationDepthClipStateCreateInfoEXT, or VkPipelineRasterizationLineStateCreateInfoEXT" + }, + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-parameter", + "text": " polygonMode must be a valid VkPolygonMode value" + }, + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-cullMode-parameter", + "text": " cullMode must be a valid combination of VkCullModeFlagBits values" + }, + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-frontFace-parameter", + "text": " frontFace must be a valid VkFrontFace value" + } + ], + "!(VK_NV_fill_rectangle)": [ + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01413", + "text": " If the non-solid fill modes feature is not enabled, polygonMode must be VK_POLYGON_MODE_FILL" + } + ], + "(VK_NV_fill_rectangle)": [ + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01507", + "text": " If the non-solid fill modes feature is not enabled, polygonMode must be VK_POLYGON_MODE_FILL or VK_POLYGON_MODE_FILL_RECTANGLE_NV" + }, + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01414", + "text": " If the VK_NV_fill_rectangle extension is not enabled, polygonMode must not be VK_POLYGON_MODE_FILL_RECTANGLE_NV" + } + ], + "(VK_KHR_portability_subset)": [ + { + "vuid": "VUID-VkPipelineRasterizationStateCreateInfo-pointPolygons-04458", + "text": " If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::pointPolygons is VK_FALSE, and rasterizerDiscardEnable is VK_FALSE, polygonMode must not be VK_POLYGON_MODE_POINT" + } + ] + }, + "VkPipelineRasterizationDepthClipStateCreateInfoEXT": { + "(VK_EXT_depth_clip_enable)": [ + { + "vuid": "VUID-VkPipelineRasterizationDepthClipStateCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkPipelineRasterizationDepthClipStateCreateInfoEXT-flags-zerobitmask", + "text": " flags must be 0" + } + ] + }, + "VkPipelineMultisampleStateCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-sampleShadingEnable-00784", + "text": " If the sample rate shading feature is not enabled, sampleShadingEnable must be VK_FALSE" + }, + { + "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-alphaToOneEnable-00785", + "text": " If the alpha to one feature is not enabled, alphaToOneEnable must be VK_FALSE" + }, + { + "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-minSampleShading-00786", + "text": " minSampleShading must be in the range [0,1]" + }, + { + "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkPipelineSampleLocationsStateCreateInfoEXT" + }, + { + "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-parameter", + "text": " rasterizationSamples must be a valid VkSampleCountFlagBits value" + }, + { + "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-pSampleMask-parameter", + "text": " If pSampleMask is not NULL, pSampleMask must be a valid pointer to an array of \\(\\lceil{\\mathit{rasterizationSamples} \\over 32}\\rceil\\) VkSampleMask values" + } + ], + "(VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-01415", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the subpass has any color attachments and rasterizationSamples is greater than the number of color samples, then sampleShadingEnable must be VK_FALSE" + } + ] + }, + "vkCmdSetRasterizerDiscardEnableEXT": { + "(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdSetRasterizerDiscardEnableEXT-None-04871", + "text": " The extendedDynamicState2 feature must be enabled" + }, + { + "vuid": "VUID-vkCmdSetRasterizerDiscardEnableEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetRasterizerDiscardEnableEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetRasterizerDiscardEnableEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "VkPipelineRasterizationStateStreamCreateInfoEXT": { + "(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-VkPipelineRasterizationStateStreamCreateInfoEXT-geometryStreams-02324", + "text": " VkPhysicalDeviceTransformFeedbackFeaturesEXT::geometryStreams must be enabled" + }, + { + "vuid": "VUID-VkPipelineRasterizationStateStreamCreateInfoEXT-rasterizationStream-02325", + "text": " rasterizationStream must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreams" + }, + { + "vuid": "VUID-VkPipelineRasterizationStateStreamCreateInfoEXT-rasterizationStream-02326", + "text": " rasterizationStream must be zero if VkPhysicalDeviceTransformFeedbackPropertiesEXT::transformFeedbackRasterizationStreamSelect is VK_FALSE" + } + ] + }, + "VkPipelineSampleLocationsStateCreateInfoEXT": { + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sampleLocationsInfo-parameter", + "text": " sampleLocationsInfo must be a valid VkSampleLocationsInfoEXT structure" + } + ] + }, + "VkSampleLocationsInfoEXT": { + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-01526", + "text": " sampleLocationsPerPixel must be a bit value that is set in VkPhysicalDeviceSampleLocationsPropertiesEXT::sampleLocationSampleCounts" + }, + { + "vuid": "VUID-VkSampleLocationsInfoEXT-sampleLocationsCount-01527", + "text": " sampleLocationsCount must equal sampleLocationsPerPixel {times} sampleLocationGridSize.width {times} sampleLocationGridSize.height" + }, + { + "vuid": "VUID-VkSampleLocationsInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT" + }, + { + "vuid": "VUID-VkSampleLocationsInfoEXT-pSampleLocations-parameter", + "text": " If sampleLocationsCount is not 0, pSampleLocations must be a valid pointer to an array of sampleLocationsCount VkSampleLocationEXT structures" + } + ] + }, + "vkCmdSetSampleLocationsEXT": { + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdSetSampleLocationsEXT-sampleLocationsPerPixel-01529", + "text": " The sampleLocationsPerPixel member of pSampleLocationsInfo must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" + }, + { + "vuid": "VUID-vkCmdSetSampleLocationsEXT-variableSampleLocations-01530", + "text": " If VkPhysicalDeviceSampleLocationsPropertiesEXT::variableSampleLocations is VK_FALSE then the current render pass must have been begun by specifying a VkRenderPassSampleLocationsBeginInfoEXT structure whose pPostSubpassSampleLocations member contains an element with a subpassIndex matching the current subpass index and the sampleLocationsInfo member of that element must match the sample locations state pointed to by pSampleLocationsInfo" + }, + { + "vuid": "VUID-vkCmdSetSampleLocationsEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetSampleLocationsEXT-pSampleLocationsInfo-parameter", + "text": " pSampleLocationsInfo must be a valid pointer to a valid VkSampleLocationsInfoEXT structure" + }, + { + "vuid": "VUID-vkCmdSetSampleLocationsEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetSampleLocationsEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkGetPhysicalDeviceFragmentShadingRatesKHR": { + "(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceFragmentShadingRatesKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceFragmentShadingRatesKHR-pFragmentShadingRateCount-parameter", + "text": " pFragmentShadingRateCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceFragmentShadingRatesKHR-pFragmentShadingRates-parameter", + "text": " If the value referenced by pFragmentShadingRateCount is not 0, and pFragmentShadingRates is not NULL, pFragmentShadingRates must be a valid pointer to an array of pFragmentShadingRateCount VkPhysicalDeviceFragmentShadingRateKHR structures" + } + ] + }, + "VkPhysicalDeviceFragmentShadingRateKHR": { + "(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-VkPhysicalDeviceFragmentShadingRateKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR" + }, + { + "vuid": "VUID-VkPhysicalDeviceFragmentShadingRateKHR-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "VkPipelineFragmentShadingRateStateCreateInfoKHR": { + "(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-VkPipelineFragmentShadingRateStateCreateInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR" + }, + { + "vuid": "VUID-VkPipelineFragmentShadingRateStateCreateInfoKHR-combinerOps-parameter", + "text": " Any given element of combinerOps must be a valid VkFragmentShadingRateCombinerOpKHR value" + } + ] + }, + "vkCmdSetFragmentShadingRateKHR": { + "(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-vkCmdSetFragmentShadingRateKHR-pipelineFragmentShadingRate-04507", + "text": " If pipelineFragmentShadingRate is not enabled, pFragmentSize->width must be 1" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateKHR-pipelineFragmentShadingRate-04508", + "text": " If pipelineFragmentShadingRate is not enabled, pFragmentSize->height must be 1" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateKHR-pipelineFragmentShadingRate-04509", + "text": " One of pipelineFragmentShadingRate, primitiveFragmentShadingRate, or attachmentFragmentShadingRate must be enabled" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateKHR-primitiveFragmentShadingRate-04510", + "text": " If the primitiveFragmentShadingRate feature is not enabled, combinerOps[0] must be VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateKHR-attachmentFragmentShadingRate-04511", + "text": " If the attachmentFragmentShadingRate feature is not enabled, combinerOps[1] must be VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateKHR-fragmentSizeNonTrivialCombinerOps-04512", + "text": " If the fragmentSizeNonTrivialCombinerOps limit is not supported, elements of combinerOps must be either VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR or VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateKHR-pFragmentSize-04513", + "text": " pFragmentSize->width must be greater than or equal to 1" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateKHR-pFragmentSize-04514", + "text": " pFragmentSize->height must be greater than or equal to 1" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateKHR-pFragmentSize-04515", + "text": " pFragmentSize->width must be a power-of-two value" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateKHR-pFragmentSize-04516", + "text": " pFragmentSize->height must be a power-of-two value" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateKHR-pFragmentSize-04517", + "text": " pFragmentSize->width must be less than or equal to 4" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateKHR-pFragmentSize-04518", + "text": " pFragmentSize->height must be less than or equal to 4" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateKHR-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateKHR-pFragmentSize-parameter", + "text": " pFragmentSize must be a valid pointer to a valid VkExtent2D structure" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateKHR-combinerOps-parameter", + "text": " Any given element of combinerOps must be a valid VkFragmentShadingRateCombinerOpKHR value" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateKHR-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateKHR-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkCmdSetFragmentShadingRateEnumNV": { + "(VK_NV_fragment_shading_rate_enums)": [ + { + "vuid": "VUID-vkCmdSetFragmentShadingRateEnumNV-pipelineFragmentShadingRate-04576", + "text": " If pipelineFragmentShadingRate is not enabled, shadingRate must be VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateEnumNV-supersampleFragmentShadingRates-04577", + "text": " If supersampleFragmentShadingRates is not enabled, shadingRate must not be VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV, VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV, VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV, or VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateEnumNV-noInvocationFragmentShadingRates-04578", + "text": " If noInvocationFragmentShadingRates is not enabled, shadingRate must not be VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateEnumNV-fragmentShadingRateEnums-04579", + "text": " fragmentShadingRateEnums must be enabled" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateEnumNV-pipelineFragmentShadingRate-04580", + "text": " One of pipelineFragmentShadingRate, primitiveFragmentShadingRate, or attachmentFragmentShadingRate must be enabled" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateEnumNV-primitiveFragmentShadingRate-04581", + "text": " If the primitiveFragmentShadingRate feature is not enabled, combinerOps[0] must be VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateEnumNV-attachmentFragmentShadingRate-04582", + "text": " If the attachmentFragmentShadingRate feature is not enabled, combinerOps[1] must be VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR" + }, + { + "vuid": "VUID-vkCmdSetFragmentShadingRateEnumNV-fragmentSizeNonTrivialCombinerOps-04583", + "text": " If the fragmentSizeNonTrivialCombinerOps limit is not supported, elements of combinerOps must be either VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR or VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR" + } + ] + }, + "VkPipelineViewportShadingRateImageStateCreateInfoNV": { + "(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-viewportCount-02054", + "text": " If the multiple viewports feature is not enabled, viewportCount must be 0 or 1" + }, + { + "vuid": "VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-viewportCount-02055", + "text": " viewportCount must be less than or equal to VkPhysicalDeviceLimits::maxViewports" + }, + { + "vuid": "VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-shadingRateImageEnable-02056", + "text": " If shadingRateImageEnable is VK_TRUE, viewportCount must be greater or equal to the viewportCount member of VkPipelineViewportStateCreateInfo" + } + ] + }, + "vkCmdBindShadingRateImageNV": { + "(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdBindShadingRateImageNV-None-02058", + "text": " The shading rate image feature must be enabled" + }, + { + "vuid": "VUID-vkCmdBindShadingRateImageNV-imageView-02059", + "text": " If imageView is not VK_NULL_HANDLE, it must be a valid VkImageView handle of type VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY" + }, + { + "vuid": "VUID-vkCmdBindShadingRateImageNV-imageView-02060", + "text": " If imageView is not VK_NULL_HANDLE, it must have a format of VK_FORMAT_R8_UINT" + }, + { + "vuid": "VUID-vkCmdBindShadingRateImageNV-imageView-02061", + "text": " If imageView is not VK_NULL_HANDLE, it must have been created with a usage value including VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV" + }, + { + "vuid": "VUID-vkCmdBindShadingRateImageNV-imageView-02062", + "text": " If imageView is not VK_NULL_HANDLE, imageLayout must match the actual VkImageLayout of each subresource accessible from imageView at the time the subresource is accessed" + }, + { + "vuid": "VUID-vkCmdBindShadingRateImageNV-imageLayout-02063", + "text": " If imageView is not VK_NULL_HANDLE, imageLayout must be VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV or VK_IMAGE_LAYOUT_GENERAL" + } + ] + }, + "vkCmdSetViewportShadingRatePaletteNV": { + "(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdSetViewportShadingRatePaletteNV-None-02064", + "text": " The shading rate image feature must be enabled" + }, + { + "vuid": "VUID-vkCmdSetViewportShadingRatePaletteNV-firstViewport-02067", + "text": " The sum of firstViewport and viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive" + }, + { + "vuid": "VUID-vkCmdSetViewportShadingRatePaletteNV-firstViewport-02068", + "text": " If the multiple viewports feature is not enabled, firstViewport must be 0" + }, + { + "vuid": "VUID-vkCmdSetViewportShadingRatePaletteNV-viewportCount-02069", + "text": " If the multiple viewports feature is not enabled, viewportCount must be 1" + } + ] + }, + "VkShadingRatePaletteNV": { + "(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkShadingRatePaletteNV-shadingRatePaletteEntryCount-02071", + "text": " shadingRatePaletteEntryCount must be between 1 and VkPhysicalDeviceShadingRateImagePropertiesNV::shadingRatePaletteSize, inclusive" + } + ] + }, + "VkPipelineViewportCoarseSampleOrderStateCreateInfoNV": { + "(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkPipelineViewportCoarseSampleOrderStateCreateInfoNV-sampleOrderType-02072", + "text": " If sampleOrderType is not VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV, customSamplerOrderCount must be 0" + }, + { + "vuid": "VUID-VkPipelineViewportCoarseSampleOrderStateCreateInfoNV-pCustomSampleOrders-02234", + "text": " The array pCustomSampleOrders must not contain two structures with matching values for both the shadingRate and sampleCount members" + } + ] + }, + "VkCoarseSampleOrderCustomNV": { + "(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkCoarseSampleOrderCustomNV-shadingRate-02073", + "text": " shadingRate must be a shading rate that generates fragments with more than one pixel" + }, + { + "vuid": "VUID-VkCoarseSampleOrderCustomNV-sampleCount-02074", + "text": " sampleCount must correspond to a sample count enumerated in VkSampleCountFlags whose corresponding bit is set in VkPhysicalDeviceLimits::framebufferNoAttachmentsSampleCounts" + }, + { + "vuid": "VUID-VkCoarseSampleOrderCustomNV-sampleLocationCount-02075", + "text": " sampleLocationCount must be equal to the product of sampleCount, the fragment width for shadingRate, and the fragment height for shadingRate" + }, + { + "vuid": "VUID-VkCoarseSampleOrderCustomNV-sampleLocationCount-02076", + "text": " sampleLocationCount must be less than or equal to the value of VkPhysicalDeviceShadingRateImagePropertiesNV::shadingRateMaxCoarseSamples" + }, + { + "vuid": "VUID-VkCoarseSampleOrderCustomNV-pSampleLocations-02077", + "text": " The array pSampleLocations must contain exactly one entry for every combination of valid values for pixelX, pixelY, and sample in the structure VkCoarseSampleOrderCustomNV" + } + ] + }, + "VkCoarseSampleLocationNV": { + "(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-VkCoarseSampleLocationNV-pixelX-02078", + "text": " pixelX must be less than the width (in pixels) of the fragment" + }, + { + "vuid": "VUID-VkCoarseSampleLocationNV-pixelY-02079", + "text": " pixelY must be less than the height (in pixels) of the fragment" + }, + { + "vuid": "VUID-VkCoarseSampleLocationNV-sample-02080", + "text": " sample must be less than the number of coverage samples in each pixel belonging to the fragment" + } + ] + }, + "vkCmdSetCoarseSampleOrderNV": { + "(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdSetCoarseSampleOrderNV-sampleOrderType-02081", + "text": " If sampleOrderType is not VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV, customSamplerOrderCount must be 0" + }, + { + "vuid": "VUID-vkCmdSetCoarseSampleOrderNV-pCustomSampleOrders-02235", + "text": " The array pCustomSampleOrders must not contain two structures with matching values for both the shadingRate and sampleCount members" + } + ] + }, + "VkPipelineRasterizationLineStateCreateInfoEXT": { + "(VK_EXT_line_rasterization)": [ + { + "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02768", + "text": " If lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the rectangularLines feature must be enabled" + }, + { + "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02769", + "text": " If lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT, then the bresenhamLines feature must be enabled" + }, + { + "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02770", + "text": " If lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT, then the smoothLines feature must be enabled" + }, + { + "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02771", + "text": " If stippledLineEnable is VK_TRUE and lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the stippledRectangularLines feature must be enabled" + }, + { + "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02772", + "text": " If stippledLineEnable is VK_TRUE and lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT, then the stippledBresenhamLines feature must be enabled" + }, + { + "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02773", + "text": " If stippledLineEnable is VK_TRUE and lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT, then the stippledSmoothLines feature must be enabled" + }, + { + "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02774", + "text": " If stippledLineEnable is VK_TRUE and lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE" + }, + { + "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-parameter", + "text": " lineRasterizationMode must be a valid VkLineRasterizationModeEXT value" + } + ] + }, + "vkCmdSetLineWidth": { + "core": [ + { + "vuid": "VUID-vkCmdSetLineWidth-lineWidth-00788", + "text": " If the wide lines feature is not enabled, lineWidth must be 1.0" + }, + { + "vuid": "VUID-vkCmdSetLineWidth-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetLineWidth-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetLineWidth-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkCmdSetLineStippleEXT": { + "(VK_EXT_line_rasterization)": [ + { + "vuid": "VUID-vkCmdSetLineStippleEXT-lineStippleFactor-02776", + "text": " lineStippleFactor must be in the range [1,256]" + }, + { + "vuid": "VUID-vkCmdSetLineStippleEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetLineStippleEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetLineStippleEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkCmdSetFrontFaceEXT": { + "(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetFrontFaceEXT-None-03383", + "text": " The extendedDynamicState feature must be enabled" + }, + { + "vuid": "VUID-vkCmdSetFrontFaceEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetFrontFaceEXT-frontFace-parameter", + "text": " frontFace must be a valid VkFrontFace value" + }, + { + "vuid": "VUID-vkCmdSetFrontFaceEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetFrontFaceEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkCmdSetCullModeEXT": { + "(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetCullModeEXT-None-03384", + "text": " The extendedDynamicState feature must be enabled" + }, + { + "vuid": "VUID-vkCmdSetCullModeEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetCullModeEXT-cullMode-parameter", + "text": " cullMode must be a valid combination of VkCullModeFlagBits values" + }, + { + "vuid": "VUID-vkCmdSetCullModeEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetCullModeEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkCmdSetDepthBiasEnableEXT": { + "(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdSetDepthBiasEnableEXT-None-04872", + "text": " The extendedDynamicState2 feature must be enabled" + }, + { + "vuid": "VUID-vkCmdSetDepthBiasEnableEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetDepthBiasEnableEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetDepthBiasEnableEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkCmdSetDepthBias": { + "core": [ + { + "vuid": "VUID-vkCmdSetDepthBias-depthBiasClamp-00790", + "text": " If the depth bias clamping feature is not enabled, depthBiasClamp must be 0.0" + }, + { + "vuid": "VUID-vkCmdSetDepthBias-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetDepthBias-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetDepthBias-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "VkPipelineRasterizationConservativeStateCreateInfoEXT": { + "(VK_EXT_conservative_rasterization)": [ + { + "vuid": "VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-extraPrimitiveOverestimationSize-01769", + "text": " extraPrimitiveOverestimationSize must be in the range of 0.0 to VkPhysicalDeviceConservativeRasterizationPropertiesEXT::maxExtraPrimitiveOverestimationSize inclusive" + }, + { + "vuid": "VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-conservativeRasterizationMode-parameter", + "text": " conservativeRasterizationMode must be a valid VkConservativeRasterizationModeEXT value" + } + ] + }, + "VkPipelineDiscardRectangleStateCreateInfoEXT": { + "(VK_EXT_discard_rectangles)": [ + { + "vuid": "VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-discardRectangleCount-00582", + "text": " discardRectangleCount must be less than or equal to VkPhysicalDeviceDiscardRectanglePropertiesEXT::maxDiscardRectangles" + }, + { + "vuid": "VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-discardRectangleMode-parameter", + "text": " discardRectangleMode must be a valid VkDiscardRectangleModeEXT value" + } + ] + }, + "vkCmdSetDiscardRectangleEXT": { + "(VK_EXT_discard_rectangles)": [ + { + "vuid": "VUID-vkCmdSetDiscardRectangleEXT-firstDiscardRectangle-00585", + "text": " The sum of firstDiscardRectangle and discardRectangleCount must be less than or equal to VkPhysicalDeviceDiscardRectanglePropertiesEXT::maxDiscardRectangles" + }, + { + "vuid": "VUID-vkCmdSetDiscardRectangleEXT-x-00587", + "text": " The x and y member of offset in each VkRect2D element of pDiscardRectangles must be greater than or equal to 0" + }, + { + "vuid": "VUID-vkCmdSetDiscardRectangleEXT-offset-00588", + "text": " Evaluation of (offset.x + extent.width) in each VkRect2D element of pDiscardRectangles must not cause a signed integer addition overflow" + }, + { + "vuid": "VUID-vkCmdSetDiscardRectangleEXT-offset-00589", + "text": " Evaluation of (offset.y + extent.height) in each VkRect2D element of pDiscardRectangles must not cause a signed integer addition overflow" + }, + { + "vuid": "VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetDiscardRectangleEXT-pDiscardRectangles-parameter", + "text": " pDiscardRectangles must be a valid pointer to an array of discardRectangleCount VkRect2D structures" + }, + { + "vuid": "VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdSetDiscardRectangleEXT-discardRectangleCount-arraylength", + "text": " discardRectangleCount must be greater than 0" + } + ], + "(VK_EXT_discard_rectangles)+(VK_NV_inherited_viewport_scissor)": [ + { + "vuid": "VUID-vkCmdSetDiscardRectangleEXT-viewportScissor2D-04788", + "text": " If this command is recorded in a secondary command buffer with VkCommandBufferInheritanceViewportScissorInfoNV::viewportScissor2D enabled, then this function must not be called" + } + ] + }, + "vkCmdSetScissor": { + "core": [ + { + "vuid": "VUID-vkCmdSetScissor-firstScissor-00592", + "text": " The sum of firstScissor and scissorCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive" + }, + { + "vuid": "VUID-vkCmdSetScissor-firstScissor-00593", + "text": " If the multiple viewports feature is not enabled, firstScissor must be 0" + }, + { + "vuid": "VUID-vkCmdSetScissor-scissorCount-00594", + "text": " If the multiple viewports feature is not enabled, scissorCount must be 1" + }, + { + "vuid": "VUID-vkCmdSetScissor-x-00595", + "text": " The x and y members of offset member of any element of pScissors must be greater than or equal to 0" + }, + { + "vuid": "VUID-vkCmdSetScissor-offset-00596", + "text": " Evaluation of (offset.x + extent.width) must not cause a signed integer addition overflow for any element of pScissors" + }, + { + "vuid": "VUID-vkCmdSetScissor-offset-00597", + "text": " Evaluation of (offset.y + extent.height) must not cause a signed integer addition overflow for any element of pScissors" + }, + { + "vuid": "VUID-vkCmdSetScissor-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetScissor-pScissors-parameter", + "text": " pScissors must be a valid pointer to an array of scissorCount VkRect2D structures" + }, + { + "vuid": "VUID-vkCmdSetScissor-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetScissor-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdSetScissor-scissorCount-arraylength", + "text": " scissorCount must be greater than 0" + } + ], + "(VK_NV_inherited_viewport_scissor)": [ + { + "vuid": "VUID-vkCmdSetScissor-viewportScissor2D-04789", + "text": " If this command is recorded in a secondary command buffer with VkCommandBufferInheritanceViewportScissorInfoNV::viewportScissor2D enabled, then this function must not be called" + } + ] + }, + "VkPipelineViewportExclusiveScissorStateCreateInfoNV": { + "(VK_NV_scissor_exclusive)": [ + { + "vuid": "VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02027", + "text": " If the multiple viewports feature is not enabled, exclusiveScissorCount must be 0 or 1" + }, + { + "vuid": "VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02028", + "text": " exclusiveScissorCount must be less than or equal to VkPhysicalDeviceLimits::maxViewports" + }, + { + "vuid": "VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02029", + "text": " exclusiveScissorCount must be 0 or greater than or equal to the viewportCount member of VkPipelineViewportStateCreateInfo" + } + ] + }, + "vkCmdSetExclusiveScissorNV": { + "(VK_NV_scissor_exclusive)": [ + { + "vuid": "VUID-vkCmdSetExclusiveScissorNV-None-02031", + "text": " The exclusive scissor feature must be enabled" + }, + { + "vuid": "VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02034", + "text": " The sum of firstExclusiveScissor and exclusiveScissorCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive" + }, + { + "vuid": "VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02035", + "text": " If the multiple viewports feature is not enabled, firstExclusiveScissor must be 0" + }, + { + "vuid": "VUID-vkCmdSetExclusiveScissorNV-exclusiveScissorCount-02036", + "text": " If the multiple viewports feature is not enabled, exclusiveScissorCount must be 1" + }, + { + "vuid": "VUID-vkCmdSetExclusiveScissorNV-x-02037", + "text": " The x and y members of offset in each member of pExclusiveScissors must be greater than or equal to 0" + }, + { + "vuid": "VUID-vkCmdSetExclusiveScissorNV-offset-02038", + "text": " Evaluation of (offset.x + extent.width) for each member of pExclusiveScissors must not cause a signed integer addition overflow" + }, + { + "vuid": "VUID-vkCmdSetExclusiveScissorNV-offset-02039", + "text": " Evaluation of (offset.y + extent.height) for each member of pExclusiveScissors must not cause a signed integer addition overflow" + } + ] + }, + "VkPipelineDepthStencilStateCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-depthBoundsTestEnable-00598", + "text": " If the depth bounds testing feature is not enabled, depthBoundsTestEnable must be VK_FALSE" + }, + { + "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-depthCompareOp-parameter", + "text": " depthCompareOp must be a valid VkCompareOp value" + }, + { + "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-front-parameter", + "text": " front must be a valid VkStencilOpState structure" + }, + { + "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-back-parameter", + "text": " back must be a valid VkStencilOpState structure" + } + ], + "(VK_KHR_portability_subset)": [ + { + "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-separateStencilMaskRef-04453", + "text": " If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::separateStencilMaskRef is VK_FALSE, and the value of VkPipelineDepthStencilStateCreateInfo::stencilTestEnable is VK_TRUE, and the value of VkPipelineRasterizationStateCreateInfo::cullMode is VK_CULL_MODE_NONE, the value of reference in each of the VkStencilOpState structs in front and back must be the same" + } + ], + "(VK_ARM_rasterization_order_attachment_access)": [ + { + "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-rasterizationOrderDepthAttachmentAccess-06463", + "text": " If the rasterizationOrderDepthAttachmentAccess feature is not enabled, flags must not include VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM" + }, + { + "vuid": "VUID-VkPipelineDepthStencilStateCreateInfo-rasterizationOrderStencilAttachmentAccess-06464", + "text": " If the rasterizationOrderStencilAttachmentAccess feature is not enabled, flags must not include VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM" + } + ] + }, + "vkCmdSetDepthBoundsTestEnableEXT": { + "(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetDepthBoundsTestEnableEXT-None-03349", + "text": " The extendedDynamicState feature must be enabled" + }, + { + "vuid": "VUID-vkCmdSetDepthBoundsTestEnableEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetDepthBoundsTestEnableEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetDepthBoundsTestEnableEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkCmdSetDepthBounds": { + "(VK_EXT_depth_range_unrestricted)": [ + { + "vuid": "VUID-vkCmdSetDepthBounds-minDepthBounds-00600", + "text": " Unless the VK_EXT_depth_range_unrestricted extension is enabled minDepthBounds must be between 0.0 and 1.0, inclusive" + }, + { + "vuid": "VUID-vkCmdSetDepthBounds-maxDepthBounds-00601", + "text": " Unless the VK_EXT_depth_range_unrestricted extension is enabled maxDepthBounds must be between 0.0 and 1.0, inclusive" + } + ], + "!(VK_EXT_depth_range_unrestricted)": [ + { + "vuid": "VUID-vkCmdSetDepthBounds-minDepthBounds-02508", + "text": " minDepthBounds must be between 0.0 and 1.0, inclusive" + }, + { + "vuid": "VUID-vkCmdSetDepthBounds-maxDepthBounds-02509", + "text": " maxDepthBounds must be between 0.0 and 1.0, inclusive" + } + ], + "core": [ + { + "vuid": "VUID-vkCmdSetDepthBounds-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetDepthBounds-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetDepthBounds-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkCmdSetStencilTestEnableEXT": { + "(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetStencilTestEnableEXT-None-03350", + "text": " The extendedDynamicState feature must be enabled" + }, + { + "vuid": "VUID-vkCmdSetStencilTestEnableEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetStencilTestEnableEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetStencilTestEnableEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkCmdSetStencilOpEXT": { + "(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetStencilOpEXT-None-03351", + "text": " The extendedDynamicState feature must be enabled" + }, + { + "vuid": "VUID-vkCmdSetStencilOpEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetStencilOpEXT-faceMask-parameter", + "text": " faceMask must be a valid combination of VkStencilFaceFlagBits values" + }, + { + "vuid": "VUID-vkCmdSetStencilOpEXT-faceMask-requiredbitmask", + "text": " faceMask must not be 0" + }, + { + "vuid": "VUID-vkCmdSetStencilOpEXT-failOp-parameter", + "text": " failOp must be a valid VkStencilOp value" + }, + { + "vuid": "VUID-vkCmdSetStencilOpEXT-passOp-parameter", + "text": " passOp must be a valid VkStencilOp value" + }, + { + "vuid": "VUID-vkCmdSetStencilOpEXT-depthFailOp-parameter", + "text": " depthFailOp must be a valid VkStencilOp value" + }, + { + "vuid": "VUID-vkCmdSetStencilOpEXT-compareOp-parameter", + "text": " compareOp must be a valid VkCompareOp value" + }, + { + "vuid": "VUID-vkCmdSetStencilOpEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetStencilOpEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "VkStencilOpState": { + "core": [ + { + "vuid": "VUID-VkStencilOpState-failOp-parameter", + "text": " failOp must be a valid VkStencilOp value" + }, + { + "vuid": "VUID-VkStencilOpState-passOp-parameter", + "text": " passOp must be a valid VkStencilOp value" + }, + { + "vuid": "VUID-VkStencilOpState-depthFailOp-parameter", + "text": " depthFailOp must be a valid VkStencilOp value" + }, + { + "vuid": "VUID-VkStencilOpState-compareOp-parameter", + "text": " compareOp must be a valid VkCompareOp value" + } + ] + }, + "vkCmdSetStencilCompareMask": { + "core": [ + { + "vuid": "VUID-vkCmdSetStencilCompareMask-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetStencilCompareMask-faceMask-parameter", + "text": " faceMask must be a valid combination of VkStencilFaceFlagBits values" + }, + { + "vuid": "VUID-vkCmdSetStencilCompareMask-faceMask-requiredbitmask", + "text": " faceMask must not be 0" + }, + { + "vuid": "VUID-vkCmdSetStencilCompareMask-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetStencilCompareMask-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkCmdSetStencilWriteMask": { + "core": [ + { + "vuid": "VUID-vkCmdSetStencilWriteMask-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetStencilWriteMask-faceMask-parameter", + "text": " faceMask must be a valid combination of VkStencilFaceFlagBits values" + }, + { + "vuid": "VUID-vkCmdSetStencilWriteMask-faceMask-requiredbitmask", + "text": " faceMask must not be 0" + }, + { + "vuid": "VUID-vkCmdSetStencilWriteMask-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetStencilWriteMask-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkCmdSetStencilReference": { + "core": [ + { + "vuid": "VUID-vkCmdSetStencilReference-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetStencilReference-faceMask-parameter", + "text": " faceMask must be a valid combination of VkStencilFaceFlagBits values" + }, + { + "vuid": "VUID-vkCmdSetStencilReference-faceMask-requiredbitmask", + "text": " faceMask must not be 0" + }, + { + "vuid": "VUID-vkCmdSetStencilReference-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetStencilReference-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkCmdSetDepthTestEnableEXT": { + "(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetDepthTestEnableEXT-None-03352", + "text": " The extendedDynamicState feature must be enabled" + }, + { + "vuid": "VUID-vkCmdSetDepthTestEnableEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetDepthTestEnableEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetDepthTestEnableEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkCmdSetDepthCompareOpEXT": { + "(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetDepthCompareOpEXT-None-03353", + "text": " The extendedDynamicState feature must be enabled" + }, + { + "vuid": "VUID-vkCmdSetDepthCompareOpEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetDepthCompareOpEXT-depthCompareOp-parameter", + "text": " depthCompareOp must be a valid VkCompareOp value" + }, + { + "vuid": "VUID-vkCmdSetDepthCompareOpEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetDepthCompareOpEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkCmdSetDepthWriteEnableEXT": { + "(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetDepthWriteEnableEXT-None-03354", + "text": " The extendedDynamicState feature must be enabled" + }, + { + "vuid": "VUID-vkCmdSetDepthWriteEnableEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetDepthWriteEnableEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetDepthWriteEnableEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "VkPipelineCoverageToColorStateCreateInfoNV": { + "(VK_NV_fragment_coverage_to_color)": [ + { + "vuid": "VUID-VkPipelineCoverageToColorStateCreateInfoNV-coverageToColorEnable-01404", + "text": " If coverageToColorEnable is VK_TRUE, then the render pass subpass indicated by VkGraphicsPipelineCreateInfo::renderPass and VkGraphicsPipelineCreateInfo::subpass must have a color attachment at the location selected by coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" + } + ] + }, + "VkPipelineCoverageModulationStateCreateInfoNV": { + "(VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationTableEnable-01405", + "text": " If coverageModulationTableEnable is VK_TRUE, coverageModulationTableCount must be equal to the number of rasterization samples divided by the number of color samples in the subpass" + } + ] + }, + "VkPipelineColorBlendStateCreateInfo": { + "core": [ + { + "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-pAttachments-00605", + "text": " If the independent blending feature is not enabled, all elements of pAttachments must be identical" + }, + { + "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-logicOpEnable-00606", + "text": " If the logic operations feature is not enabled, logicOpEnable must be VK_FALSE" + }, + { + "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-logicOpEnable-00607", + "text": " If logicOpEnable is VK_TRUE, logicOp must be a valid VkLogicOp value" + }, + { + "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO" + }, + { + "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineColorBlendAdvancedStateCreateInfoEXT or VkPipelineColorWriteCreateInfoEXT" + }, + { + "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-pAttachments-parameter", + "text": " If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkPipelineColorBlendAttachmentState structures" + } + ], + "(VK_ARM_rasterization_order_attachment_access)": [ + { + "vuid": "VUID-VkPipelineColorBlendStateCreateInfo-rasterizationOrderColorAttachmentAccess-06465", + "text": " If the rasterizationOrderColorAttachmentAccess feature is not enabled, flags must not include VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM" + } + ] + }, + "VkPipelineColorBlendAttachmentState": { + "core": [ + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-srcColorBlendFactor-00608", + "text": " If the dual source blending feature is not enabled, srcColorBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-dstColorBlendFactor-00609", + "text": " If the dual source blending feature is not enabled, dstColorBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-srcAlphaBlendFactor-00610", + "text": " If the dual source blending feature is not enabled, srcAlphaBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-dstAlphaBlendFactor-00611", + "text": " If the dual source blending feature is not enabled, dstAlphaBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-srcColorBlendFactor-parameter", + "text": " srcColorBlendFactor must be a valid VkBlendFactor value" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-dstColorBlendFactor-parameter", + "text": " dstColorBlendFactor must be a valid VkBlendFactor value" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-parameter", + "text": " colorBlendOp must be a valid VkBlendOp value" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-srcAlphaBlendFactor-parameter", + "text": " srcAlphaBlendFactor must be a valid VkBlendFactor value" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-dstAlphaBlendFactor-parameter", + "text": " dstAlphaBlendFactor must be a valid VkBlendFactor value" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-alphaBlendOp-parameter", + "text": " alphaBlendOp must be a valid VkBlendOp value" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-colorWriteMask-parameter", + "text": " colorWriteMask must be a valid combination of VkColorComponentFlagBits values" + } + ], + "(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-01406", + "text": " If either of colorBlendOp or alphaBlendOp is an advanced blend operation, then colorBlendOp must equal alphaBlendOp" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-advancedBlendIndependentBlend-01407", + "text": " If VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendIndependentBlend is VK_FALSE and colorBlendOp is an advanced blend operation, then colorBlendOp must be the same for all attachments" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-advancedBlendIndependentBlend-01408", + "text": " If VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendIndependentBlend is VK_FALSE and alphaBlendOp is an advanced blend operation, then alphaBlendOp must be the same for all attachments" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-advancedBlendAllOperations-01409", + "text": " If VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendAllOperations is VK_FALSE, then colorBlendOp must not be VK_BLEND_OP_ZERO_EXT, VK_BLEND_OP_SRC_EXT, VK_BLEND_OP_DST_EXT, VK_BLEND_OP_SRC_OVER_EXT, VK_BLEND_OP_DST_OVER_EXT, VK_BLEND_OP_SRC_IN_EXT, VK_BLEND_OP_DST_IN_EXT, VK_BLEND_OP_SRC_OUT_EXT, VK_BLEND_OP_DST_OUT_EXT, VK_BLEND_OP_SRC_ATOP_EXT, VK_BLEND_OP_DST_ATOP_EXT, VK_BLEND_OP_XOR_EXT, VK_BLEND_OP_INVERT_EXT, VK_BLEND_OP_INVERT_RGB_EXT, VK_BLEND_OP_LINEARDODGE_EXT, VK_BLEND_OP_LINEARBURN_EXT, VK_BLEND_OP_VIVIDLIGHT_EXT, VK_BLEND_OP_LINEARLIGHT_EXT, VK_BLEND_OP_PINLIGHT_EXT, VK_BLEND_OP_HARDMIX_EXT, VK_BLEND_OP_PLUS_EXT, VK_BLEND_OP_PLUS_CLAMPED_EXT, VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT, VK_BLEND_OP_PLUS_DARKER_EXT, VK_BLEND_OP_MINUS_EXT, VK_BLEND_OP_MINUS_CLAMPED_EXT, VK_BLEND_OP_CONTRAST_EXT, VK_BLEND_OP_INVERT_OVG_EXT, VK_BLEND_OP_RED_EXT, VK_BLEND_OP_GREEN_EXT, or VK_BLEND_OP_BLUE_EXT" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-01410", + "text": " If colorBlendOp or alphaBlendOp is an advanced blend operation, then colorAttachmentCount of the subpass this pipeline is compiled against must be less than or equal to VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendMaxColorAttachments" + } + ], + "(VK_KHR_portability_subset)": [ + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-constantAlphaColorBlendFactors-04454", + "text": " If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::constantAlphaColorBlendFactors is VK_FALSE, srcColorBlendFactor must not be VK_BLEND_FACTOR_CONSTANT_ALPHA or VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA" + }, + { + "vuid": "VUID-VkPipelineColorBlendAttachmentState-constantAlphaColorBlendFactors-04455", + "text": " If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::constantAlphaColorBlendFactors is VK_FALSE, dstColorBlendFactor must not be VK_BLEND_FACTOR_CONSTANT_ALPHA or VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA" + } + ] + }, + "vkCmdSetBlendConstants": { + "core": [ + { + "vuid": "VUID-vkCmdSetBlendConstants-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetBlendConstants-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetBlendConstants-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "VkPipelineColorBlendAdvancedStateCreateInfoEXT": { + "(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-srcPremultiplied-01424", + "text": " If the non-premultiplied source color property is not supported, srcPremultiplied must be VK_TRUE" + }, + { + "vuid": "VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-dstPremultiplied-01425", + "text": " If the non-premultiplied destination color property is not supported, dstPremultiplied must be VK_TRUE" + }, + { + "vuid": "VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-blendOverlap-01426", + "text": " If the correlated overlap property is not supported, blendOverlap must be VK_BLEND_OVERLAP_UNCORRELATED_EXT" + }, + { + "vuid": "VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkPipelineColorBlendAdvancedStateCreateInfoEXT-blendOverlap-parameter", + "text": " blendOverlap must be a valid VkBlendOverlapEXT value" + } + ] + }, + "vkCmdSetLogicOpEXT": { + "(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdSetLogicOpEXT-None-04867", + "text": " The extendedDynamicState2LogicOp feature must be enabled" + }, + { + "vuid": "VUID-vkCmdSetLogicOpEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetLogicOpEXT-logicOp-parameter", + "text": " logicOp must be a valid VkLogicOp value" + }, + { + "vuid": "VUID-vkCmdSetLogicOpEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetLogicOpEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "VkPipelineColorWriteCreateInfoEXT": { + "(VK_EXT_color_write_enable)": [ + { + "vuid": "VUID-VkPipelineColorWriteCreateInfoEXT-pAttachments-04801", + "text": " If the colorWriteEnable feature is not enabled, all elements of pColorWriteEnables must be VK_TRUE" + }, + { + "vuid": "VUID-VkPipelineColorWriteCreateInfoEXT-attachmentCount-04802", + "text": " attachmentCount must be equal to the attachmentCount member of the VkPipelineColorBlendStateCreateInfo structure specified during pipeline creation" + }, + { + "vuid": "VUID-VkPipelineColorWriteCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkPipelineColorWriteCreateInfoEXT-pColorWriteEnables-parameter", + "text": " If attachmentCount is not 0, pColorWriteEnables must be a valid pointer to an array of attachmentCount VkBool32 values" + } + ] + }, + "vkCmdSetColorWriteEnableEXT": { + "(VK_EXT_color_write_enable)": [ + { + "vuid": "VUID-vkCmdSetColorWriteEnableEXT-None-04803", + "text": " The colorWriteEnable feature must be enabled" + }, + { + "vuid": "VUID-vkCmdSetColorWriteEnableEXT-attachmentCount-04804", + "text": " attachmentCount must be equal to the attachmentCount member of the VkPipelineColorBlendStateCreateInfo structure specified during pipeline creation" + }, + { + "vuid": "VUID-vkCmdSetColorWriteEnableEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdSetColorWriteEnableEXT-pColorWriteEnables-parameter", + "text": " pColorWriteEnables must be a valid pointer to an array of attachmentCount VkBool32 values" + }, + { + "vuid": "VUID-vkCmdSetColorWriteEnableEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdSetColorWriteEnableEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdSetColorWriteEnableEXT-attachmentCount-arraylength", + "text": " attachmentCount must be greater than 0" + } + ] + }, + "vkCmdDispatch": { + "core": [ + { + "vuid": "VUID-vkCmdDispatch-magFilter-04553", + "text": " If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDispatch-mipmapMode-04770", + "text": " If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDispatch-None-02691", + "text": " If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" + }, + { + "vuid": "VUID-vkCmdDispatch-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDispatch-None-02699", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDispatch-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDispatch-commandBuffer-02701", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the VK_NV_inherited_viewport_scissor extension is enabled) for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic" + }, + { + "vuid": "VUID-vkCmdDispatch-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDispatch-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatch-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatch-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatch-None-02705", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDispatch-None-02706", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDispatch-None-04115", + "text": " If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format" + }, + { + "vuid": "VUID-vkCmdDispatch-OpImageWrite-04469", + "text": " If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format" + }, + { + "vuid": "VUID-vkCmdDispatch-groupCountX-00386", + "text": " groupCountX must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]" + }, + { + "vuid": "VUID-vkCmdDispatch-groupCountY-00387", + "text": " groupCountY must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]" + }, + { + "vuid": "VUID-vkCmdDispatch-groupCountZ-00388", + "text": " groupCountZ must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]" + }, + { + "vuid": "VUID-vkCmdDispatch-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDispatch-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdDispatch-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support compute operations" + }, + { + "vuid": "VUID-vkCmdDispatch-renderpass", + "text": " This command must only be called outside of a render pass instance" + } + ], + "!(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDispatch-aspectMask-06478", + "text": " If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT." + } + ], + "(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDispatch-None-06479", + "text": " If a VkImageView is sampled with depth comparison, the image view’s format features must contain VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDispatch-OpTypeImage-06423", + "text": " Any VkImageView or VkBufferView being written as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDispatch-OpTypeImage-06424", + "text": " Any VkImageView or VkBufferView being read as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR" + } + ], + "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDispatch-None-02692", + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + } + ], + "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+!(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDispatch-None-02693", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDispatch-filterCubic-02694", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2" + }, + { + "vuid": "VUID-vkCmdDispatch-filterCubicMinmax-02695", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2" + } + ], + "(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-vkCmdDispatch-flags-02696", + "text": " Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE" + } + ], + "!(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDispatch-None-02698", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDispatch-maintenance4-06425", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDispatch-commandBuffer-02707", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" + }, + { + "vuid": "VUID-vkCmdDispatch-commandBuffer-02712", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, any resource written to by the VkPipeline object bound to the pipeline bind point used by this command must not be an unprotected resource" + }, + { + "vuid": "VUID-vkCmdDispatch-commandBuffer-02713", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, pipeline stages other than the framebuffer-space and compute stages in the VkPipeline object bound to the pipeline bind point used by this command must not write to any resource" + }, + { + "vuid": "VUID-vkCmdDispatch-commandBuffer-04617", + "text": " If any of the shader stages of the VkPipeline bound to the pipeline bind point used by this command uses the RayQueryKHR capability, then commandBuffer must not be a protected command buffer" + } + ], + "(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-vkCmdDispatch-SampledType-04470", + "text": " If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDispatch-SampledType-04471", + "text": " If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDispatch-SampledType-04472", + "text": " If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDispatch-SampledType-04473", + "text": " If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDispatch-sparseImageInt64Atomics-04474", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + }, + { + "vuid": "VUID-vkCmdDispatch-sparseImageInt64Atomics-04475", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + } + ] + }, + "vkCmdDispatchIndirect": { + "core": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-magFilter-04553", + "text": " If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-mipmapMode-04770", + "text": " If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-02691", + "text": " If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-02699", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-02701", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the VK_NV_inherited_viewport_scissor extension is enabled) for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-02705", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-02706", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-04115", + "text": " If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-OpImageWrite-04469", + "text": " If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-buffer-02708", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-buffer-02709", + "text": " buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-offset-02710", + "text": " offset must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-offset-00407", + "text": " The sum of offset and the size of VkDispatchIndirectCommand must be less than or equal to the size of buffer" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-buffer-parameter", + "text": " buffer must be a valid VkBuffer handle" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support compute operations" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-renderpass", + "text": " This command must only be called outside of a render pass instance" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-commonparent", + "text": " Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "!(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-aspectMask-06478", + "text": " If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT." + } + ], + "(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-None-06479", + "text": " If a VkImageView is sampled with depth comparison, the image view’s format features must contain VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-OpTypeImage-06423", + "text": " Any VkImageView or VkBufferView being written as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-OpTypeImage-06424", + "text": " Any VkImageView or VkBufferView being read as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR" + } + ], + "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-None-02692", + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + } + ], + "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+!(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-None-02693", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-filterCubic-02694", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-filterCubicMinmax-02695", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2" + } + ], + "(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-flags-02696", + "text": " Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE" + } + ], + "!(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-None-02698", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-maintenance4-06425", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-02707", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-02711", + "text": " commandBuffer must not be a protected command buffer" + } + ], + "(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-SampledType-04470", + "text": " If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-SampledType-04471", + "text": " If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-SampledType-04472", + "text": " If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-SampledType-04473", + "text": " If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-sparseImageInt64Atomics-04474", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-sparseImageInt64Atomics-04475", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + } + ] + }, + "VkDispatchIndirectCommand": { + "core": [ + { + "vuid": "VUID-VkDispatchIndirectCommand-x-00417", + "text": " x must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]" + }, + { + "vuid": "VUID-VkDispatchIndirectCommand-y-00418", + "text": " y must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]" + }, + { + "vuid": "VUID-VkDispatchIndirectCommand-z-00419", + "text": " z must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]" + } + ] + }, + "vkCmdDispatchBase": { + "(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkCmdDispatchBase-magFilter-04553", + "text": " If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDispatchBase-mipmapMode-04770", + "text": " If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-02691", + "text": " If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-02699", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDispatchBase-commandBuffer-02701", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the VK_NV_inherited_viewport_scissor extension is enabled) for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-02705", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-02706", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-04115", + "text": " If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format" + }, + { + "vuid": "VUID-vkCmdDispatchBase-OpImageWrite-04469", + "text": " If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format" + }, + { + "vuid": "VUID-vkCmdDispatchBase-baseGroupX-00421", + "text": " baseGroupX must be less than VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]" + }, + { + "vuid": "VUID-vkCmdDispatchBase-baseGroupX-00422", + "text": " baseGroupY must be less than VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]" + }, + { + "vuid": "VUID-vkCmdDispatchBase-baseGroupZ-00423", + "text": " baseGroupZ must be less than VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]" + }, + { + "vuid": "VUID-vkCmdDispatchBase-groupCountX-00424", + "text": " groupCountX must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0] minus baseGroupX" + }, + { + "vuid": "VUID-vkCmdDispatchBase-groupCountY-00425", + "text": " groupCountY must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1] minus baseGroupY" + }, + { + "vuid": "VUID-vkCmdDispatchBase-groupCountZ-00426", + "text": " groupCountZ must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2] minus baseGroupZ" + }, + { + "vuid": "VUID-vkCmdDispatchBase-baseGroupX-00427", + "text": " If any of baseGroupX, baseGroupY, or baseGroupZ are not zero, then the bound compute pipeline must have been created with the VK_PIPELINE_CREATE_DISPATCH_BASE flag" + }, + { + "vuid": "VUID-vkCmdDispatchBase-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdDispatchBase-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdDispatchBase-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support compute operations" + }, + { + "vuid": "VUID-vkCmdDispatchBase-renderpass", + "text": " This command must only be called outside of a render pass instance" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)+!(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDispatchBase-aspectMask-06478", + "text": " If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT." + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdDispatchBase-None-06479", + "text": " If a VkImageView is sampled with depth comparison, the image view’s format features must contain VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDispatchBase-OpTypeImage-06423", + "text": " Any VkImageView or VkBufferView being written as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdDispatchBase-OpTypeImage-06424", + "text": " Any VkImageView or VkBufferView being read as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDispatchBase-None-02692", + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+!(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDispatchBase-None-02693", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdDispatchBase-filterCubic-02694", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2" + }, + { + "vuid": "VUID-vkCmdDispatchBase-filterCubicMinmax-02695", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-vkCmdDispatchBase-flags-02696", + "text": " Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)+!(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDispatchBase-None-02698", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdDispatchBase-maintenance4-06425", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDispatchBase-commandBuffer-02707", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" + }, + { + "vuid": "VUID-vkCmdDispatchBase-commandBuffer-02712", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, any resource written to by the VkPipeline object bound to the pipeline bind point used by this command must not be an unprotected resource" + }, + { + "vuid": "VUID-vkCmdDispatchBase-commandBuffer-02713", + "text": " If commandBuffer is a protected command buffer and protectedNoFault is not supported, pipeline stages other than the framebuffer-space and compute stages in the VkPipeline object bound to the pipeline bind point used by this command must not write to any resource" + }, + { + "vuid": "VUID-vkCmdDispatchBase-commandBuffer-04617", + "text": " If any of the shader stages of the VkPipeline bound to the pipeline bind point used by this command uses the RayQueryKHR capability, then commandBuffer must not be a protected command buffer" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-vkCmdDispatchBase-SampledType-04470", + "text": " If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDispatchBase-SampledType-04471", + "text": " If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDispatchBase-SampledType-04472", + "text": " If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdDispatchBase-SampledType-04473", + "text": " If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdDispatchBase-sparseImageInt64Atomics-04474", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + }, + { + "vuid": "VUID-vkCmdDispatchBase-sparseImageInt64Atomics-04475", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + } + ] + }, + "vkCmdSubpassShadingHUAWEI": { + "(VK_HUAWEI_subpass_shading)": [ + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-magFilter-04553", + "text": " If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-mipmapMode-04770", + "text": " If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02691", + "text": " If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02699", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-commandBuffer-02701", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the VK_NV_inherited_viewport_scissor extension is enabled) for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02705", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02706", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-04115", + "text": " If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-OpImageWrite-04469", + "text": " If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-04931", + "text": " This command must be called in a subpass with bind point VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI. No draw commands can be called in the same subpass. Only one vkCmdSubpassShadingHUAWEI command can be called in a subpass" + } + ], + "(VK_HUAWEI_subpass_shading)+!(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-aspectMask-06478", + "text": " If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT." + } + ], + "(VK_HUAWEI_subpass_shading)+(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-06479", + "text": " If a VkImageView is sampled with depth comparison, the image view’s format features must contain VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-OpTypeImage-06423", + "text": " Any VkImageView or VkBufferView being written as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-OpTypeImage-06424", + "text": " Any VkImageView or VkBufferView being read as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR" + } + ], + "(VK_HUAWEI_subpass_shading)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02692", + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + } + ], + "(VK_HUAWEI_subpass_shading)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+!(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02693", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_HUAWEI_subpass_shading)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-filterCubic-02694", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-filterCubicMinmax-02695", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2" + } + ], + "(VK_HUAWEI_subpass_shading)+(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-flags-02696", + "text": " Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE" + } + ], + "(VK_HUAWEI_subpass_shading)+!(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02698", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_HUAWEI_subpass_shading)+(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-maintenance4-06425", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_HUAWEI_subpass_shading)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-commandBuffer-02707", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_HUAWEI_subpass_shading)+(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-SampledType-04470", + "text": " If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-SampledType-04471", + "text": " If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-SampledType-04472", + "text": " If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-SampledType-04473", + "text": " If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-sparseImageInt64Atomics-04474", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-sparseImageInt64Atomics-04475", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + } + ] + }, + "vkCreateIndirectCommandsLayoutNV": { + "(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-vkCreateIndirectCommandsLayoutNV-deviceGeneratedCommands-02929", + "text": " The VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::deviceGeneratedCommands feature must be enabled" + } + ] + }, + "VkIndirectCommandsLayoutCreateInfoNV": { + "(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNV-pipelineBindPoint-02930", + "text": " The pipelineBindPoint must be VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNV-tokenCount-02931", + "text": " tokenCount must be greater than 0 and less than or equal to VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::maxIndirectCommandsTokenCount" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNV-pTokens-02932", + "text": " If pTokens contains an entry of VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV it must be the first element of the array and there must be only a single element of such token type" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNV-pTokens-02933", + "text": " If pTokens contains an entry of VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV there must be only a single element of such token type" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNV-pTokens-02934", + "text": " All state tokens in pTokens must occur prior work provoking tokens (VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV)" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNV-pTokens-02935", + "text": " The content of pTokens must include one single work provoking token that is compatible with the pipelineBindPoint" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNV-streamCount-02936", + "text": " streamCount must be greater than 0 and less or equal to VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::maxIndirectCommandsStreamCount" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNV-pStreamStrides-02937", + "text": " each element of pStreamStrides must be greater than `0`and less than or equal to VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::maxIndirectCommandsStreamStride. Furthermore the alignment of each token input must be ensured" + } + ] + }, + "vkDestroyIndirectCommandsLayoutNV": { + "(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-vkDestroyIndirectCommandsLayoutNV-indirectCommandsLayout-02938", + "text": " All submitted commands that refer to indirectCommandsLayout must have completed execution" + }, + { + "vuid": "VUID-vkDestroyIndirectCommandsLayoutNV-deviceGeneratedCommands-02941", + "text": " The VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::deviceGeneratedCommands feature must be enabled" + } + ], + "(VK_NV_device_generated_commands)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyIndirectCommandsLayoutNV-indirectCommandsLayout-02939", + "text": " If VkAllocationCallbacks were provided when indirectCommandsLayout was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyIndirectCommandsLayoutNV-indirectCommandsLayout-02940", + "text": " If no VkAllocationCallbacks were provided when indirectCommandsLayout was created, pAllocator must be NULL" + } + ] + }, + "VkIndirectCommandsStreamNV": { + "(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-VkIndirectCommandsStreamNV-buffer-02942", + "text": " The buffer’s usage flag must have the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-VkIndirectCommandsStreamNV-offset-02943", + "text": " The offset must be aligned to VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::minIndirectCommandsBufferOffsetAlignment" + }, + { + "vuid": "VUID-VkIndirectCommandsStreamNV-buffer-02975", + "text": " If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + } + ] + }, + "VkBindShaderGroupIndirectCommandNV": { + "(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-VkBindShaderGroupIndirectCommandNV-None-02944", + "text": " The current bound graphics pipeline, as well as the pipelines it may reference, must have been created with VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV" + }, + { + "vuid": "VUID-VkBindShaderGroupIndirectCommandNV-index-02945", + "text": " The index must be within range of the accessible shader groups of the current bound graphics pipeline. See vkCmdBindPipelineShaderGroupNV for further details" + } + ] + }, + "VkBindIndexBufferIndirectCommandNV": { + "(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-VkBindIndexBufferIndirectCommandNV-None-02946", + "text": " The buffer’s usage flag from which the address was acquired must have the VK_BUFFER_USAGE_INDEX_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-VkBindIndexBufferIndirectCommandNV-bufferAddress-02947", + "text": " The bufferAddress must be aligned to the indexType used" + }, + { + "vuid": "VUID-VkBindIndexBufferIndirectCommandNV-None-02948", + "text": " Each element of the buffer from which the address was acquired and that is non-sparse must be bound completely and contiguously to a single VkDeviceMemory object" + } + ] + }, + "VkBindVertexBufferIndirectCommandNV": { + "(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-VkBindVertexBufferIndirectCommandNV-None-02949", + "text": " The buffer’s usage flag from which the address was acquired must have the VK_BUFFER_USAGE_VERTEX_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-VkBindVertexBufferIndirectCommandNV-None-02950", + "text": " Each element of the buffer from which the address was acquired and that is non-sparse must be bound completely and contiguously to a single VkDeviceMemory object" + } + ] + }, + "VkIndirectCommandsLayoutTokenNV": { + "(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-stream-02951", + "text": " stream must be smaller than VkIndirectCommandsLayoutCreateInfoNV::streamCount" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-offset-02952", + "text": " offset must be less than or equal to VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::maxIndirectCommandsTokenOffset" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-tokenType-02976", + "text": " If tokenType is VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV, vertexBindingUnit must stay within device supported limits for the appropriate commands" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-tokenType-02977", + "text": " If tokenType is VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV, pushconstantPipelineLayout must be valid" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-tokenType-02978", + "text": " If tokenType is VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV, pushconstantOffset must be a multiple of 4" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-tokenType-02979", + "text": " If tokenType is VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV, pushconstantSize must be a multiple of 4" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-tokenType-02980", + "text": " If tokenType is VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV, pushconstantOffset must be less than VkPhysicalDeviceLimits::maxPushConstantsSize" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-tokenType-02981", + "text": " If tokenType is VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV, pushconstantSize must be less than or equal to VkPhysicalDeviceLimits::maxPushConstantsSize minus pushconstantOffset" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-tokenType-02982", + "text": " If tokenType is VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV, for each byte in the range specified by pushconstantOffset and pushconstantSize and for each shader stage in pushconstantShaderStageFlags, there must be a push constant range in pushconstantPipelineLayout that includes that byte and that stage" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-tokenType-02983", + "text": " If tokenType is VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV, for each byte in the range specified by pushconstantOffset and pushconstantSize and for each push constant range that overlaps that byte, pushconstantShaderStageFlags must include all stages in that push constant range’s VkPushConstantRange::stageFlags" + }, + { + "vuid": "VUID-VkIndirectCommandsLayoutTokenNV-tokenType-02984", + "text": " If tokenType is VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV, indirectStateFlags must not be 0" + } + ] + }, + "vkGetGeneratedCommandsMemoryRequirementsNV": { + "(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-vkGetGeneratedCommandsMemoryRequirementsNV-deviceGeneratedCommands-02906", + "text": " The VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::deviceGeneratedCommands feature must be enabled" + } + ] + }, + "VkGeneratedCommandsMemoryRequirementsInfoNV": { + "(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-VkGeneratedCommandsMemoryRequirementsInfoNV-maxSequencesCount-02907", + "text": " maxSequencesCount must be less or equal to VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::maxIndirectSequenceCount" + } + ] + }, + "vkCmdExecuteGeneratedCommandsNV": { + "(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-magFilter-04553", + "text": " If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-mipmapMode-04770", + "text": " If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02691", + "text": " If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02699", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-commandBuffer-02701", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the VK_NV_inherited_viewport_scissor extension is enabled) for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02705", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02706", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-04115", + "text": " If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-OpImageWrite-04469", + "text": " If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-renderPass-02684", + "text": " The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-subpass-02685", + "text": " The subpass index of the current render pass must be equal to the subpass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02686", + "text": " Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-04584", + "text": " Image subresources used as attachments in the current render pass must not be accessed in any way other than as an attachment by this command, except for cases involving read-only access to depth/stencil attachments as described in the Render Pass chapter" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-blendEnable-04727", + "text": " If rasterization is not disabled in the bound graphics pipeline, then for each color attachment in the subpass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the blendEnable member of the corresponding element of the pAttachments member of pColorBlendState must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-rasterizationSamples-04740", + "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then VkPipelineMultisampleStateCreateInfo::rasterizationSamples must be the same as the current subpass color and/or depth/stencil attachments" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-04007", + "text": " All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have either valid or VK_NULL_HANDLE buffers bound" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-04008", + "text": " If the nullDescriptor feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02721", + "text": " For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding, as described in Vertex Input Description" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-isPreprocessed-02908", + "text": " If isPreprocessed is VK_TRUE then vkCmdPreprocessGeneratedCommandsNV must have already been executed on the device, using the same pGeneratedCommandsInfo content as well as the content of the input buffers it references (all except VkGeneratedCommandsInfoNV::preprocessBuffer). Furthermore pGeneratedCommandsInfo`s indirectCommandsLayout must have been created with the VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV bit set" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-pipeline-02909", + "text": " VkGeneratedCommandsInfoNV::pipeline must match the current bound pipeline at VkGeneratedCommandsInfoNV::pipelineBindPoint" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-deviceGeneratedCommands-02911", + "text": " The VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::deviceGeneratedCommands feature must be enabled" + } + ], + "(VK_NV_device_generated_commands)+!(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-aspectMask-06478", + "text": " If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT." + } + ], + "(VK_NV_device_generated_commands)+(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-06479", + "text": " If a VkImageView is sampled with depth comparison, the image view’s format features must contain VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-OpTypeImage-06423", + "text": " Any VkImageView or VkBufferView being written as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-OpTypeImage-06424", + "text": " Any VkImageView or VkBufferView being read as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR" + } + ], + "(VK_NV_device_generated_commands)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02692", + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + } + ], + "(VK_NV_device_generated_commands)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+!(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02693", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_NV_device_generated_commands)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-filterCubic-02694", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-filterCubicMinmax-02695", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2" + } + ], + "(VK_NV_device_generated_commands)+(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-flags-02696", + "text": " Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE" + } + ], + "(VK_NV_device_generated_commands)+!(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02698", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_device_generated_commands)+(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-maintenance4-06425", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_device_generated_commands)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-commandBuffer-02707", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-commandBuffer-02970", + "text": " commandBuffer must not be a protected command buffer" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-SampledType-04470", + "text": " If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-SampledType-04471", + "text": " If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-SampledType-04472", + "text": " If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-SampledType-04473", + "text": " If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-sparseImageInt64Atomics-04474", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-sparseImageInt64Atomics-04475", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + } + ], + "(VK_NV_device_generated_commands)+(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-maxMultiviewInstanceIndex-02688", + "text": " If the draw is recorded in a render pass instance with multiview enabled, the maximum instance index must be less than or equal to VkPhysicalDeviceMultiviewProperties::maxMultiviewInstanceIndex" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-sampleLocationsEnable-02689", + "text": " If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE and the current subpass has a depth/stencil attachment, then that attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-viewportCount-03417", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the VkPipelineViewportStateCreateInfo::scissorCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-scissorCount-03418", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, then vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the scissorCount parameter of vkCmdSetScissorWithCountEXT must match the VkPipelineViewportStateCreateInfo::viewportCount of the pipeline" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-viewportCount-03419", + "text": " If the bound graphics pipeline state was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic states enabled then both vkCmdSetViewportWithCountEXT and vkCmdSetScissorWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the scissorCount parameter of vkCmdSetScissorWithCountEXT" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-primitiveTopology-03420", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT dynamic state enabled then vkCmdSetPrimitiveTopologyEXT must have been called in the current command buffer prior to this drawing command, and the primitiveTopology parameter of vkCmdSetPrimitiveTopologyEXT must be of the same topology class as the pipeline VkPipelineInputAssemblyStateCreateInfo::topology state" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-viewportCount-04137", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportWScalingStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-viewportCount-04138", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-viewportCount-04139", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportShadingRateImageStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-viewportCount-04140", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-VkPipelineVieportCreateInfo-04141", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportSwizzleStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-VkPipelineVieportCreateInfo-04142", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled and a VkPipelineViewportExclusiveScissorStateCreateInfoNV structure chained from VkPipelineVieportCreateInfo, then the bound graphics pipeline must have been created with VkPipelineViewportExclusiveScissorStateCreateInfoNV::exclusiveScissorCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCountEXT" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-04876", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT dynamic state enabled then vkCmdSetRasterizerDiscardEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-04877", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT dynamic state enabled then vkCmdSetDepthBiasEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-logicOp-04878", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-04875", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT dynamic state enabled then vkCmdSetPatchControlPointsEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-04879", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-primitiveFragmentShadingRateWithMultipleViewports-04552", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must be 1" + } + ], + "(VK_NV_device_generated_commands)+(VK_KHR_dynamic_rendering)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-imageView-06172", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-imageView-06173", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-viewMask-06178", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::viewMask equal to VkRenderingInfoKHR::viewMask" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-colorAttachmentCount-06179", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound graphics pipeline must have been created with a VkPipelineRenderingCreateInfoKHR::colorAttachmentCount equal to VkRenderingInfoKHR::colorAttachmentCount" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-colorAttachmentCount-06180", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::colorAttachmentCount greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a VkFormat equal to the corresponding element of VkPipelineRenderingCreateInfoKHR::pColorAttachmentFormats used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-pDepthAttachment-06181", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::depthAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-pStencilAttachment-06182", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineRenderingCreateInfoKHR::stencilAttachmentFormat used to create the currently bound graphics pipeline must be equal to the VkFormat used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + } + ], + "(VK_NV_device_generated_commands)+(VK_KHR_dynamic_rendering)+(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-imageView-06174", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-imageView-06175", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_NV_device_generated_commands)+(VK_KHR_dynamic_rendering)+(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-imageView-06176", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pDepthAttachment is not VK_NULL_HANDLE, and the layout member of pDepthAttachment is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, this command must not write any values to the depth attachment" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-imageView-06177", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the imageView member of pStencilAttachment is not VK_NULL_HANDLE, and the layout member of pStencilAttachment is VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, this command must not write any values to the stencil attachment" + } + ], + "(VK_NV_device_generated_commands)+(VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-imageView-06183", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentShadingRateAttachmentInfoKHR::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" + } + ], + "(VK_NV_device_generated_commands)+(VK_KHR_dynamic_rendering)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-imageView-06184", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR and VkRenderingFragmentDensityMapAttachmentInfoEXT::imageView was not VK_NULL_HANDLE, the currently bound graphics pipeline must have been created with VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT" + } + ], + "(VK_NV_device_generated_commands)+(VK_KHR_dynamic_rendering)+(VK_AMD_mixed_attachment_samples,VK_NV_framebuffer_mixed_samples)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-colorAttachmentCount-06185", + "text": " If the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the corresponding element of the pColorAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-pDepthAttachment-06186", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-pStencilAttachment-06187", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created with a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of the depthStencilAttachmentSamples member of VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-colorAttachmentCount-06188", + "text": " If the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and the current render pass instance was begun with vkCmdBeginRenderingKHR with a VkRenderingInfoKHR::colorAttachmentCount parameter greater than 0, then each element of the VkRenderingInfoKHR::pColorAttachments array with a imageView not equal to VK_NULL_HANDLE must have been created with a sample count equal to the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-pDepthAttachment-06189", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pDepthAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pDepthAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-pStencilAttachment-06190", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline was created without a VkAttachmentSampleCountInfoAMD or VkAttachmentSampleCountInfoNV structure, and VkRenderingInfoKHR::pStencilAttachment->pname:imageView was not VK_NULL_HANDLE, the value of VkPipelineMultisampleStateCreateInfo::rasterizationSamples used to create the currently bound graphics pipeline must be equal to the sample count used to create VkRenderingInfoKHR::pStencilAttachment->pname:imageView" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-renderPass-06198", + "text": " If the current render pass instance was begun with vkCmdBeginRenderingKHR, the currently bound pipeline must have been created with a VkGraphicsPipelineCreateInfo::renderPass equal to VK_NULL_HANDLE" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state)+(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-04912", + "text": " If the bound graphics pipeline was created with both the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT and VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic states enabled, then vkCmdSetVertexInputEXT must have been called in the current command buffer prior to this draw command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-pStrides-04913", + "text": " If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic state enabled, but not the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state)+!(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-pStrides-04884", + "text": " If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called in the current command buffer prior to this drawing command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-04914", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdSetVertexInputEXT must have been called in the current command buffer prior to this draw command" + } + ], + "(VK_NV_device_generated_commands)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-stage-06481", + "text": " The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of an element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_TASK_BIT_NV or VK_SHADER_STAGE_MESH_BIT_NV" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02910", + "text": " Transform feedback must not be active" + } + ] + }, + "VkGeneratedCommandsInfoNV": { + "(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-VkGeneratedCommandsInfoNV-pipeline-02912", + "text": " The provided pipeline must match the pipeline bound at execution time" + }, + { + "vuid": "VUID-VkGeneratedCommandsInfoNV-indirectCommandsLayout-02913", + "text": " If the indirectCommandsLayout uses a token of VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV, then the pipeline must have been created with multiple shader groups" + }, + { + "vuid": "VUID-VkGeneratedCommandsInfoNV-indirectCommandsLayout-02914", + "text": " If the indirectCommandsLayout uses a token of VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV, then the pipeline must have been created with VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV set in VkGraphicsPipelineCreateInfo::flags" + }, + { + "vuid": "VUID-VkGeneratedCommandsInfoNV-indirectCommandsLayout-02915", + "text": " If the indirectCommandsLayout uses a token of VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV, then the pipeline`s VkPipelineLayout must match the VkIndirectCommandsLayoutTokenNV::pushconstantPipelineLayout" + }, + { + "vuid": "VUID-VkGeneratedCommandsInfoNV-streamCount-02916", + "text": " streamCount must match the indirectCommandsLayout’s streamCount" + }, + { + "vuid": "VUID-VkGeneratedCommandsInfoNV-sequencesCount-02917", + "text": " sequencesCount must be less or equal to VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::maxIndirectSequenceCount and VkGeneratedCommandsMemoryRequirementsInfoNV::maxSequencesCount that was used to determine the preprocessSize" + }, + { + "vuid": "VUID-VkGeneratedCommandsInfoNV-preprocessBuffer-02918", + "text": " preprocessBuffer must have the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set in its usage flag" + }, + { + "vuid": "VUID-VkGeneratedCommandsInfoNV-preprocessOffset-02919", + "text": " preprocessOffset must be aligned to VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::minIndirectCommandsBufferOffsetAlignment" + }, + { + "vuid": "VUID-VkGeneratedCommandsInfoNV-preprocessBuffer-02971", + "text": " If preprocessBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkGeneratedCommandsInfoNV-preprocessSize-02920", + "text": " preprocessSize must be at least equal to the memory requirement`s size returned by vkGetGeneratedCommandsMemoryRequirementsNV using the matching inputs (indirectCommandsLayout, …​) as within this structure" + }, + { + "vuid": "VUID-VkGeneratedCommandsInfoNV-sequencesCountBuffer-02921", + "text": " sequencesCountBuffer can be set if the actual used count of sequences is sourced from the provided buffer. In that case the sequencesCount serves as upper bound" + }, + { + "vuid": "VUID-VkGeneratedCommandsInfoNV-sequencesCountBuffer-02922", + "text": " If sequencesCountBuffer is not VK_NULL_HANDLE, its usage flag must have the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-VkGeneratedCommandsInfoNV-sequencesCountBuffer-02923", + "text": " If sequencesCountBuffer is not VK_NULL_HANDLE, sequencesCountOffset must be aligned to VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::minSequencesCountBufferOffsetAlignment" + }, + { + "vuid": "VUID-VkGeneratedCommandsInfoNV-sequencesCountBuffer-02972", + "text": " If sequencesCountBuffer is not VK_NULL_HANDLE and is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-VkGeneratedCommandsInfoNV-sequencesIndexBuffer-02924", + "text": " If indirectCommandsLayout’s VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV is set, sequencesIndexBuffer must be set otherwise it must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkGeneratedCommandsInfoNV-sequencesIndexBuffer-02925", + "text": " If sequencesIndexBuffer is not VK_NULL_HANDLE, its usage flag must have the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-VkGeneratedCommandsInfoNV-sequencesIndexBuffer-02926", + "text": " If sequencesIndexBuffer is not VK_NULL_HANDLE, sequencesIndexOffset must be aligned to VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::minSequencesIndexBufferOffsetAlignment" + }, + { + "vuid": "VUID-VkGeneratedCommandsInfoNV-sequencesIndexBuffer-02973", + "text": " If sequencesIndexBuffer is not VK_NULL_HANDLE and is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + } + ] + }, + "vkCmdPreprocessGeneratedCommandsNV": { + "(VK_NV_device_generated_commands)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdPreprocessGeneratedCommandsNV-commandBuffer-02974", + "text": " commandBuffer must not be a protected command buffer" + } + ], + "(VK_NV_device_generated_commands)": [ + { + "vuid": "VUID-vkCmdPreprocessGeneratedCommandsNV-pGeneratedCommandsInfo-02927", + "text": " pGeneratedCommandsInfo`s indirectCommandsLayout must have been created with the VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV bit set" + }, + { + "vuid": "VUID-vkCmdPreprocessGeneratedCommandsNV-deviceGeneratedCommands-02928", + "text": " The VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::deviceGeneratedCommands feature must be enabled" + } + ] + }, + "vkGetPhysicalDeviceSparseImageFormatProperties": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-samples-01094", + "text": " samples must be a bit value that is set in VkImageFormatProperties::sampleCounts returned by vkGetPhysicalDeviceImageFormatProperties with format, type, tiling, and usage equal to those in this command and flags equal to the value that is set in VkImageCreateInfo::flags when the image is created" + } + ] + }, + "VkPhysicalDeviceSparseImageFormatInfo2": { + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-01095", + "text": " samples must be a bit value that is set in VkImageFormatProperties::sampleCounts returned by vkGetPhysicalDeviceImageFormatProperties with format, type, tiling, and usage equal to those in this command and flags equal to the value that is set in VkImageCreateInfo::flags when the image is created" + } + ] + }, + "VkSparseMemoryBind": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkSparseMemoryBind-memory-01096", + "text": " If memory is not VK_NULL_HANDLE, memory and memoryOffset must match the memory requirements of the resource, as described in section Resource Memory Association" + }, + { + "vuid": "VUID-VkSparseMemoryBind-memory-01097", + "text": " If memory is not VK_NULL_HANDLE, memory must not have been created with a memory type that reports VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT bit set" + }, + { + "vuid": "VUID-VkSparseMemoryBind-size-01098", + "text": " size must be greater than 0" + }, + { + "vuid": "VUID-VkSparseMemoryBind-resourceOffset-01099", + "text": " resourceOffset must be less than the size of the resource" + }, + { + "vuid": "VUID-VkSparseMemoryBind-size-01100", + "text": " size must be less than or equal to the size of the resource minus resourceOffset" + }, + { + "vuid": "VUID-VkSparseMemoryBind-memoryOffset-01101", + "text": " memoryOffset must be less than the size of memory" + }, + { + "vuid": "VUID-VkSparseMemoryBind-size-01102", + "text": " size must be less than or equal to the size of memory minus memoryOffset" + } + ], + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkSparseMemoryBind-memory-02730", + "text": " If memory was created with VkExportMemoryAllocateInfo::handleTypes not equal to 0, at least one handle type it contained must also have been set in VkExternalMemoryBufferCreateInfo::handleTypes or VkExternalMemoryImageCreateInfo::handleTypes when the resource was created" + }, + { + "vuid": "VUID-VkSparseMemoryBind-memory-02731", + "text": " If memory was created by a memory import operation, the external handle type of the imported memory must also have been set in VkExternalMemoryBufferCreateInfo::handleTypes or VkExternalMemoryImageCreateInfo::handleTypes when the resource was created" + } + ] + }, + "VkSparseImageOpaqueMemoryBindInfo": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkSparseImageOpaqueMemoryBindInfo-pBinds-01103", + "text": " If the flags member of any element of pBinds contains VK_SPARSE_MEMORY_BIND_METADATA_BIT, the binding range defined must be within the mip tail region of the metadata aspect of image" + } + ] + }, + "VkSparseImageMemoryBindInfo": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkSparseImageMemoryBindInfo-subresource-01722", + "text": " The subresource.mipLevel member of each element of pBinds must be less than the mipLevels specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkSparseImageMemoryBindInfo-subresource-01723", + "text": " The subresource.arrayLayer member of each element of pBinds must be less than the arrayLayers specified in VkImageCreateInfo when image was created" + }, + { + "vuid": "VUID-VkSparseImageMemoryBindInfo-image-02901", + "text": " image must have been created with VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set" + } + ] + }, + "VkSparseImageMemoryBind": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkSparseImageMemoryBind-memory-01104", + "text": " If the sparse aliased residency feature is not enabled, and if any other resources are bound to ranges of memory, the range of memory being bound must not overlap with those bound ranges" + }, + { + "vuid": "VUID-VkSparseImageMemoryBind-memory-01105", + "text": " memory and memoryOffset must match the memory requirements of the calling command’s image, as described in section Resource Memory Association" + }, + { + "vuid": "VUID-VkSparseImageMemoryBind-subresource-01106", + "text": " subresource must be a valid image subresource for image (see Image Views)" + }, + { + "vuid": "VUID-VkSparseImageMemoryBind-offset-01107", + "text": " offset.x must be a multiple of the sparse image block width (VkSparseImageFormatProperties::imageGranularity.width) of the image" + }, + { + "vuid": "VUID-VkSparseImageMemoryBind-extent-01108", + "text": " extent.width must either be a multiple of the sparse image block width of the image, or else (extent.width + offset.x) must equal the width of the image subresource" + }, + { + "vuid": "VUID-VkSparseImageMemoryBind-offset-01109", + "text": " offset.y must be a multiple of the sparse image block height (VkSparseImageFormatProperties::imageGranularity.height) of the image" + }, + { + "vuid": "VUID-VkSparseImageMemoryBind-extent-01110", + "text": " extent.height must either be a multiple of the sparse image block height of the image, or else (extent.height + offset.y) must equal the height of the image subresource" + }, + { + "vuid": "VUID-VkSparseImageMemoryBind-offset-01111", + "text": " offset.z must be a multiple of the sparse image block depth (VkSparseImageFormatProperties::imageGranularity.depth) of the image" + }, + { + "vuid": "VUID-VkSparseImageMemoryBind-extent-01112", + "text": " extent.depth must either be a multiple of the sparse image block depth of the image, or else (extent.depth + offset.z) must equal the depth of the image subresource" + } + ], + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_external_memory)": [ + { + "vuid": "VUID-VkSparseImageMemoryBind-memory-02732", + "text": " If memory was created with VkExportMemoryAllocateInfo::handleTypes not equal to 0, at least one handle type it contained must also have been set in VkExternalMemoryImageCreateInfo::handleTypes when the image was created" + }, + { + "vuid": "VUID-VkSparseImageMemoryBind-memory-02733", + "text": " If memory was created by a memory import operation, the external handle type of the imported memory must also have been set in VkExternalMemoryImageCreateInfo::handleTypes when image was created" + } + ] + }, + "vkQueueBindSparse": { + "!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkQueueBindSparse-fence-01113", + "text": " If fence is not VK_NULL_HANDLE, fence must be unsignaled" + }, + { + "vuid": "VUID-vkQueueBindSparse-fence-01114", + "text": " If fence is not VK_NULL_HANDLE, fence must not be associated with any other queue command that has not yet completed execution on that queue" + }, + { + "vuid": "VUID-vkQueueBindSparse-pSignalSemaphores-01115", + "text": " Each element of the pSignalSemaphores member of each element of pBindInfo must be unsignaled when the semaphore signal operation it defines is executed on the device" + }, + { + "vuid": "VUID-vkQueueBindSparse-pWaitSemaphores-01116", + "text": " When a semaphore wait operation referring to a binary semaphore defined by any element of the pWaitSemaphores member of any element of pBindInfo executes on queue, there must be no other queues waiting on the same semaphore" + }, + { + "vuid": "VUID-vkQueueBindSparse-pWaitSemaphores-01117", + "text": " All elements of the pWaitSemaphores member of all elements of the pBindInfo parameter referring to a binary semaphore must be semaphores that are signaled, or have semaphore signal operations previously submitted for execution" + } + ], + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-vkQueueBindSparse-pWaitSemaphores-03245", + "text": " All elements of the pWaitSemaphores member of all elements of pBindInfo created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_BINARY must reference a semaphore signal operation that has been submitted for execution and any semaphore signal operations on which it depends (if any) must have also been submitted for execution" + } + ] + }, + "VkBindSparseInfo": { + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-VkBindSparseInfo-pWaitSemaphores-03246", + "text": " If any element of pWaitSemaphores or pSignalSemaphores was created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE then the pNext chain must include a VkTimelineSemaphoreSubmitInfo structure" + }, + { + "vuid": "VUID-VkBindSparseInfo-pNext-03247", + "text": " If the pNext chain of this structure includes a VkTimelineSemaphoreSubmitInfo structure and any element of pWaitSemaphores was created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE then its waitSemaphoreValueCount member must equal waitSemaphoreCount" + }, + { + "vuid": "VUID-VkBindSparseInfo-pNext-03248", + "text": " If the pNext chain of this structure includes a VkTimelineSemaphoreSubmitInfo structure and any element of pSignalSemaphores was created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE then its signalSemaphoreValueCount member must equal signalSemaphoreCount" + }, + { + "vuid": "VUID-VkBindSparseInfo-pSignalSemaphores-03249", + "text": " For each element of pSignalSemaphores created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE the corresponding element of VkTimelineSemaphoreSubmitInfo::pSignalSemaphoreValues must have a value greater than the current value of the semaphore when the semaphore signal operation is executed" + }, + { + "vuid": "VUID-VkBindSparseInfo-pWaitSemaphores-03250", + "text": " For each element of pWaitSemaphores created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE the corresponding element of VkTimelineSemaphoreSubmitInfo::pWaitSemaphoreValues must have a value which does not differ from the current value of the semaphore or from the value of any outstanding semaphore wait or signal operation on that semaphore by more than maxTimelineSemaphoreValueDifference" + }, + { + "vuid": "VUID-VkBindSparseInfo-pSignalSemaphores-03251", + "text": " For each element of pSignalSemaphores created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_TIMELINE the corresponding element of VkTimelineSemaphoreSubmitInfo::pSignalSemaphoreValues must have a value which does not differ from the current value of the semaphore or from the value of any outstanding semaphore wait or signal operation on that semaphore by more than maxTimelineSemaphoreValueDifference" + } + ] + }, + "VkDeviceGroupBindSparseInfo": { + "!(VKSC_VERSION_1_0)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkDeviceGroupBindSparseInfo-resourceDeviceIndex-01118", + "text": " resourceDeviceIndex and memoryDeviceIndex must both be valid device indices" + }, + { + "vuid": "VUID-VkDeviceGroupBindSparseInfo-memoryDeviceIndex-01119", + "text": " Each memory allocation bound in this batch must have allocated an instance for memoryDeviceIndex" + } + ] + }, + "vkCreateAndroidSurfaceKHR": { + "(VK_KHR_surface)+(VK_KHR_android_surface)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateAndroidSurfaceKHR-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ] + }, + "VkAndroidSurfaceCreateInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_android_surface)": [ + { + "vuid": "VUID-VkAndroidSurfaceCreateInfoKHR-window-01248", + "text": " window must point to a valid Android ANativeWindow" + } + ] + }, + "vkCreateWaylandSurfaceKHR": { + "(VK_KHR_surface)+(VK_KHR_wayland_surface)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateWaylandSurfaceKHR-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ] + }, + "VkWaylandSurfaceCreateInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_wayland_surface)": [ + { + "vuid": "VUID-VkWaylandSurfaceCreateInfoKHR-display-01304", + "text": " display must point to a valid Wayland wl_display" + }, + { + "vuid": "VUID-VkWaylandSurfaceCreateInfoKHR-surface-01305", + "text": " surface must point to a valid Wayland wl_surface" + } + ] + }, + "vkCreateWin32SurfaceKHR": { + "(VK_KHR_surface)+(VK_KHR_win32_surface)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateWin32SurfaceKHR-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ] + }, + "VkWin32SurfaceCreateInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_win32_surface)": [ + { + "vuid": "VUID-VkWin32SurfaceCreateInfoKHR-hinstance-01307", + "text": " hinstance must be a valid Win32 HINSTANCE" + }, + { + "vuid": "VUID-VkWin32SurfaceCreateInfoKHR-hwnd-01308", + "text": " hwnd must be a valid Win32 HWND" + } + ] + }, + "vkCreateXcbSurfaceKHR": { + "(VK_KHR_surface)+(VK_KHR_xcb_surface)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateXcbSurfaceKHR-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ] + }, + "VkXcbSurfaceCreateInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_xcb_surface)": [ + { + "vuid": "VUID-VkXcbSurfaceCreateInfoKHR-connection-01310", + "text": " connection must point to a valid X11 xcb_connection_t" + }, + { + "vuid": "VUID-VkXcbSurfaceCreateInfoKHR-window-01311", + "text": " window must be a valid X11 xcb_window_t" + } + ] + }, + "vkCreateXlibSurfaceKHR": { + "(VK_KHR_surface)+(VK_KHR_xlib_surface)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateXlibSurfaceKHR-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ] + }, + "VkXlibSurfaceCreateInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_xlib_surface)": [ + { + "vuid": "VUID-VkXlibSurfaceCreateInfoKHR-dpy-01313", + "text": " dpy must point to a valid Xlib Display" + }, + { + "vuid": "VUID-VkXlibSurfaceCreateInfoKHR-window-01314", + "text": " window must be a valid Xlib Window" + } + ] + }, + "vkCreateDirectFBSurfaceEXT": { + "(VK_KHR_surface)+(VK_EXT_directfb_surface)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateDirectFBSurfaceEXT-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ] + }, + "VkDirectFBSurfaceCreateInfoEXT": { + "(VK_KHR_surface)+(VK_EXT_directfb_surface)": [ + { + "vuid": "VUID-VkDirectFBSurfaceCreateInfoEXT-dfb-04117", + "text": " dfb must point to a valid DirectFB IDirectFB" + }, + { + "vuid": "VUID-VkDirectFBSurfaceCreateInfoEXT-surface-04118", + "text": " surface must point to a valid DirectFB IDirectFBSurface" + } + ] + }, + "vkCreateImagePipeSurfaceFUCHSIA": { + "(VK_KHR_surface)+(VK_FUCHSIA_imagepipe_surface)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateImagePipeSurfaceFUCHSIA-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ] + }, + "VkImagePipeSurfaceCreateInfoFUCHSIA": { + "(VK_KHR_surface)+(VK_FUCHSIA_imagepipe_surface)": [ + { + "vuid": "VUID-VkImagePipeSurfaceCreateInfoFUCHSIA-imagePipeHandle-04863", + "text": " imagePipeHandle must be a valid zx_handle_t" + } + ] + }, + "vkCreateStreamDescriptorSurfaceGGP": { + "(VK_KHR_surface)+(VK_GGP_stream_descriptor_surface)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateStreamDescriptorSurfaceGGP-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ] + }, + "VkStreamDescriptorSurfaceCreateInfoGGP": { + "(VK_KHR_surface)+(VK_GGP_stream_descriptor_surface)": [ + { + "vuid": "VUID-VkStreamDescriptorSurfaceCreateInfoGGP-streamDescriptor-02681", + "text": " streamDescriptor must be a valid GgpStreamDescriptor" + } + ] + }, + "vkCreateIOSSurfaceMVK": { + "(VK_KHR_surface)+(VK_MVK_ios_surface)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateIOSSurfaceMVK-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ] + }, + "VkIOSSurfaceCreateInfoMVK": { + "(VK_KHR_surface)+(VK_MVK_ios_surface)": [ + { + "vuid": "VUID-VkIOSSurfaceCreateInfoMVK-pView-04143", + "text": " If pView is a CAMetalLayer object, it must be a valid CAMetalLayer" + }, + { + "vuid": "VUID-VkIOSSurfaceCreateInfoMVK-pView-01316", + "text": " If pView is a UIView object, it must be a valid UIView, must be backed by a CALayer object of type CAMetalLayer, and vkCreateIOSSurfaceMVK must be called on the main thread" + } + ] + }, + "vkCreateMacOSSurfaceMVK": { + "(VK_KHR_surface)+(VK_MVK_macos_surface)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateMacOSSurfaceMVK-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ] + }, + "VkMacOSSurfaceCreateInfoMVK": { + "(VK_KHR_surface)+(VK_MVK_macos_surface)": [ + { + "vuid": "VUID-VkMacOSSurfaceCreateInfoMVK-pView-04144", + "text": " If pView is a CAMetalLayer object, it must be a valid CAMetalLayer" + }, + { + "vuid": "VUID-VkMacOSSurfaceCreateInfoMVK-pView-01317", + "text": " If pView is an NSView object, it must be a valid NSView, must be backed by a CALayer object of type CAMetalLayer, and vkCreateMacOSSurfaceMVK must be called on the main thread" + } + ] + }, + "vkCreateViSurfaceNN": { + "(VK_KHR_surface)+(VK_NN_vi_surface)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateViSurfaceNN-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ] + }, + "VkViSurfaceCreateInfoNN": { + "(VK_KHR_surface)+(VK_NN_vi_surface)": [ + { + "vuid": "VUID-VkViSurfaceCreateInfoNN-window-01318", + "text": " window must be a valid nn::vi::NativeWindowHandle" + } + ] + }, + "vkCreateMetalSurfaceEXT": { + "(VK_KHR_surface)+(VK_EXT_metal_surface)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateMetalSurfaceEXT-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ] + }, + "VkScreenSurfaceCreateInfoQNX": { + "(VK_KHR_surface)+(VK_QNX_screen_surface)": [ + { + "vuid": "VUID-VkScreenSurfaceCreateInfoQNX-context-04741", + "text": " context must point to a valid QNX Screen struct _screen_context" + }, + { + "vuid": "VUID-VkScreenSurfaceCreateInfoQNX-window-04742", + "text": " window must point to a valid QNX Screen struct _screen_window" + } + ] + }, + "vkDestroySurfaceKHR": { + "(VK_KHR_surface)": [ + { + "vuid": "VUID-vkDestroySurfaceKHR-surface-01266", + "text": " All VkSwapchainKHR objects created for surface must have been destroyed prior to destroying surface" + }, + { + "vuid": "VUID-vkDestroySurfaceKHR-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkDestroySurfaceKHR-surface-parameter", + "text": " If surface is not VK_NULL_HANDLE, surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-vkDestroySurfaceKHR-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroySurfaceKHR-surface-parent", + "text": " If surface is a valid handle, it must have been created, allocated, or retrieved from instance" + } + ], + "(VK_KHR_surface)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroySurfaceKHR-surface-01267", + "text": " If VkAllocationCallbacks were provided when surface was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroySurfaceKHR-surface-01268", + "text": " If no VkAllocationCallbacks were provided when surface was created, pAllocator must be NULL" + } + ] + }, + "vkGetPhysicalDeviceDisplayPropertiesKHR": { + "(VK_KHR_surface)+(VK_KHR_display)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayPropertiesKHR structures" + } + ] + }, + "vkGetPhysicalDeviceDisplayProperties2KHR": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayProperties2KHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayProperties2KHR-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayProperties2KHR-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayProperties2KHR structures" + } + ] + }, + "VkDisplayProperties2KHR": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ + { + "vuid": "VUID-VkDisplayProperties2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR" + }, + { + "vuid": "VUID-VkDisplayProperties2KHR-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkReleaseDisplayEXT": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_direct_mode_display)": [ + { + "vuid": "VUID-vkReleaseDisplayEXT-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkReleaseDisplayEXT-display-parameter", + "text": " display must be a valid VkDisplayKHR handle" + }, + { + "vuid": "VUID-vkReleaseDisplayEXT-display-parent", + "text": " display must have been created, allocated, or retrieved from physicalDevice" + } + ] + }, + "vkGetPhysicalDeviceDisplayPlanePropertiesKHR": { + "(VK_KHR_surface)+(VK_KHR_display)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayPlanePropertiesKHR structures" + } + ] + }, + "vkGetPhysicalDeviceDisplayPlaneProperties2KHR": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayPlaneProperties2KHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayPlaneProperties2KHR-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceDisplayPlaneProperties2KHR-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayPlaneProperties2KHR structures" + } + ] + }, + "VkDisplayPlaneProperties2KHR": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ + { + "vuid": "VUID-VkDisplayPlaneProperties2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR" + }, + { + "vuid": "VUID-VkDisplayPlaneProperties2KHR-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkGetDisplayPlaneSupportedDisplaysKHR": { + "(VK_KHR_surface)+(VK_KHR_display)": [ + { + "vuid": "VUID-vkGetDisplayPlaneSupportedDisplaysKHR-planeIndex-01249", + "text": " planeIndex must be less than the number of display planes supported by the device as determined by calling vkGetPhysicalDeviceDisplayPlanePropertiesKHR" + }, + { + "vuid": "VUID-vkGetDisplayPlaneSupportedDisplaysKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetDisplayPlaneSupportedDisplaysKHR-pDisplayCount-parameter", + "text": " pDisplayCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetDisplayPlaneSupportedDisplaysKHR-pDisplays-parameter", + "text": " If the value referenced by pDisplayCount is not 0, and pDisplays is not NULL, pDisplays must be a valid pointer to an array of pDisplayCount VkDisplayKHR handles" + } + ] + }, + "vkGetDisplayModePropertiesKHR": { + "(VK_KHR_surface)+(VK_KHR_display)": [ + { + "vuid": "VUID-vkGetDisplayModePropertiesKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetDisplayModePropertiesKHR-display-parameter", + "text": " display must be a valid VkDisplayKHR handle" + }, + { + "vuid": "VUID-vkGetDisplayModePropertiesKHR-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetDisplayModePropertiesKHR-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayModePropertiesKHR structures" + }, + { + "vuid": "VUID-vkGetDisplayModePropertiesKHR-display-parent", + "text": " display must have been created, allocated, or retrieved from physicalDevice" + } + ] + }, + "vkGetDisplayModeProperties2KHR": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ + { + "vuid": "VUID-vkGetDisplayModeProperties2KHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetDisplayModeProperties2KHR-display-parameter", + "text": " display must be a valid VkDisplayKHR handle" + }, + { + "vuid": "VUID-vkGetDisplayModeProperties2KHR-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetDisplayModeProperties2KHR-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkDisplayModeProperties2KHR structures" + }, + { + "vuid": "VUID-vkGetDisplayModeProperties2KHR-display-parent", + "text": " display must have been created, allocated, or retrieved from physicalDevice" + } + ] + }, + "VkDisplayModeProperties2KHR": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ + { + "vuid": "VUID-VkDisplayModeProperties2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR" + }, + { + "vuid": "VUID-VkDisplayModeProperties2KHR-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "VkDisplayModeParametersKHR": { + "(VK_KHR_surface)+(VK_KHR_display)": [ + { + "vuid": "VUID-VkDisplayModeParametersKHR-width-01990", + "text": " The width member of visibleRegion must be greater than 0" + }, + { + "vuid": "VUID-VkDisplayModeParametersKHR-height-01991", + "text": " The height member of visibleRegion must be greater than 0" + }, + { + "vuid": "VUID-VkDisplayModeParametersKHR-refreshRate-01992", + "text": " refreshRate must be greater than 0" + } + ] + }, + "vkCreateDisplayModeKHR": { + "(VK_KHR_surface)+(VK_KHR_display)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateDisplayModeKHR-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "(VK_KHR_surface)+(VK_KHR_display)": [ + { + "vuid": "VUID-vkCreateDisplayModeKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkCreateDisplayModeKHR-display-parameter", + "text": " display must be a valid VkDisplayKHR handle" + }, + { + "vuid": "VUID-vkCreateDisplayModeKHR-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkDisplayModeCreateInfoKHR structure" + }, + { + "vuid": "VUID-vkCreateDisplayModeKHR-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateDisplayModeKHR-pMode-parameter", + "text": " pMode must be a valid pointer to a VkDisplayModeKHR handle" + }, + { + "vuid": "VUID-vkCreateDisplayModeKHR-display-parent", + "text": " display must have been created, allocated, or retrieved from physicalDevice" + } + ] + }, + "VkDisplayModeCreateInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_display)": [ + { + "vuid": "VUID-VkDisplayModeCreateInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR" + }, + { + "vuid": "VUID-VkDisplayModeCreateInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDisplayModeCreateInfoKHR-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkDisplayModeCreateInfoKHR-parameters-parameter", + "text": " parameters must be a valid VkDisplayModeParametersKHR structure" + } + ] + }, + "vkGetDisplayPlaneCapabilitiesKHR": { + "(VK_KHR_surface)+(VK_KHR_display)": [ + { + "vuid": "VUID-vkGetDisplayPlaneCapabilitiesKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetDisplayPlaneCapabilitiesKHR-mode-parameter", + "text": " mode must be a valid VkDisplayModeKHR handle" + }, + { + "vuid": "VUID-vkGetDisplayPlaneCapabilitiesKHR-pCapabilities-parameter", + "text": " pCapabilities must be a valid pointer to a VkDisplayPlaneCapabilitiesKHR structure" + } + ] + }, + "vkGetDisplayPlaneCapabilities2KHR": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ + { + "vuid": "VUID-vkGetDisplayPlaneCapabilities2KHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetDisplayPlaneCapabilities2KHR-pDisplayPlaneInfo-parameter", + "text": " pDisplayPlaneInfo must be a valid pointer to a valid VkDisplayPlaneInfo2KHR structure" + }, + { + "vuid": "VUID-vkGetDisplayPlaneCapabilities2KHR-pCapabilities-parameter", + "text": " pCapabilities must be a valid pointer to a VkDisplayPlaneCapabilities2KHR structure" + } + ] + }, + "VkDisplayPlaneInfo2KHR": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ + { + "vuid": "VUID-VkDisplayPlaneInfo2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR" + }, + { + "vuid": "VUID-VkDisplayPlaneInfo2KHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDisplayPlaneInfo2KHR-mode-parameter", + "text": " mode must be a valid VkDisplayModeKHR handle" + } + ] + }, + "VkDisplayPlaneCapabilities2KHR": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_KHR_get_display_properties2)": [ + { + "vuid": "VUID-VkDisplayPlaneCapabilities2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR" + }, + { + "vuid": "VUID-VkDisplayPlaneCapabilities2KHR-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkDisplayPowerControlEXT": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_display_control)": [ + { + "vuid": "VUID-vkDisplayPowerControlEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDisplayPowerControlEXT-display-parameter", + "text": " display must be a valid VkDisplayKHR handle" + }, + { + "vuid": "VUID-vkDisplayPowerControlEXT-pDisplayPowerInfo-parameter", + "text": " pDisplayPowerInfo must be a valid pointer to a valid VkDisplayPowerInfoEXT structure" + }, + { + "vuid": "VUID-vkDisplayPowerControlEXT-commonparent", + "text": " Both of device, and display must have been created, allocated, or retrieved from the same VkPhysicalDevice" + } + ] + }, + "VkDisplayPowerInfoEXT": { + "(VK_KHR_surface)+(VK_KHR_display)+(VK_EXT_display_control)": [ + { + "vuid": "VUID-VkDisplayPowerInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT" + }, + { + "vuid": "VUID-VkDisplayPowerInfoEXT-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDisplayPowerInfoEXT-powerState-parameter", + "text": " powerState must be a valid VkDisplayPowerStateEXT value" + } + ] + }, + "vkCreateDisplayPlaneSurfaceKHR": { + "(VK_KHR_surface)+(VK_KHR_display)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateDisplayPlaneSurfaceKHR-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "(VK_KHR_surface)+(VK_KHR_display)": [ + { + "vuid": "VUID-vkCreateDisplayPlaneSurfaceKHR-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkCreateDisplayPlaneSurfaceKHR-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkDisplaySurfaceCreateInfoKHR structure" + }, + { + "vuid": "VUID-vkCreateDisplayPlaneSurfaceKHR-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateDisplayPlaneSurfaceKHR-pSurface-parameter", + "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" + } + ] + }, + "VkDisplaySurfaceCreateInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_display)": [ + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-planeIndex-01252", + "text": " planeIndex must be less than the number of display planes supported by the device as determined by calling vkGetPhysicalDeviceDisplayPlanePropertiesKHR" + }, + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-planeReorderPossible-01253", + "text": " If the planeReorderPossible member of the VkDisplayPropertiesKHR structure returned by vkGetPhysicalDeviceDisplayPropertiesKHR for the display corresponding to displayMode is VK_TRUE then planeStackIndex must be less than the number of display planes supported by the device as determined by calling vkGetPhysicalDeviceDisplayPlanePropertiesKHR; otherwise planeStackIndex must equal the currentStackIndex member of VkDisplayPlanePropertiesKHR returned by vkGetPhysicalDeviceDisplayPlanePropertiesKHR for the display plane corresponding to displayMode" + }, + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-01254", + "text": " If alphaMode is VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR then globalAlpha must be between 0 and 1, inclusive" + }, + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-01255", + "text": " alphaMode must be one of the bits present in the supportedAlpha member of VkDisplayPlaneCapabilitiesKHR for the display plane corresponding to displayMode" + }, + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-width-01256", + "text": " The width and height members of imageExtent must be less than or equal to VkPhysicalDeviceLimits::maxImageDimension2D" + }, + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR" + }, + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-displayMode-parameter", + "text": " displayMode must be a valid VkDisplayModeKHR handle" + }, + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-transform-parameter", + "text": " transform must be a valid VkSurfaceTransformFlagBitsKHR value" + }, + { + "vuid": "VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-parameter", + "text": " alphaMode must be a valid VkDisplayPlaneAlphaFlagBitsKHR value" + } + ] + }, + "vkCreateHeadlessSurfaceEXT": { + "(VK_KHR_surface)+(VK_EXT_headless_surface)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateHeadlessSurfaceEXT-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "(VK_KHR_surface)+(VK_EXT_headless_surface)": [ + { + "vuid": "VUID-vkCreateHeadlessSurfaceEXT-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkCreateHeadlessSurfaceEXT-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkHeadlessSurfaceCreateInfoEXT structure" + }, + { + "vuid": "VUID-vkCreateHeadlessSurfaceEXT-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateHeadlessSurfaceEXT-pSurface-parameter", + "text": " pSurface must be a valid pointer to a VkSurfaceKHR handle" + } + ] + }, + "VkHeadlessSurfaceCreateInfoEXT": { + "(VK_KHR_surface)+(VK_EXT_headless_surface)": [ + { + "vuid": "VUID-VkHeadlessSurfaceCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkHeadlessSurfaceCreateInfoEXT-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkHeadlessSurfaceCreateInfoEXT-flags-zerobitmask", + "text": " flags must be 0" + } + ] + }, + "vkGetPhysicalDeviceSurfaceSupportKHR": { + "(VK_KHR_surface)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-queueFamilyIndex-01269", + "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-surface-parameter", + "text": " surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-pSupported-parameter", + "text": " pSupported must be a valid pointer to a VkBool32 value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-commonparent", + "text": " Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkGetPhysicalDeviceWaylandPresentationSupportKHR": { + "(VK_KHR_surface)+(VK_KHR_wayland_surface)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-queueFamilyIndex-01306", + "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice" + } + ] + }, + "vkGetPhysicalDeviceWin32PresentationSupportKHR": { + "(VK_KHR_surface)+(VK_KHR_win32_surface)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-queueFamilyIndex-01309", + "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice" + } + ] + }, + "vkGetPhysicalDeviceXcbPresentationSupportKHR": { + "(VK_KHR_surface)+(VK_KHR_xcb_surface)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-queueFamilyIndex-01312", + "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice" + } + ] + }, + "vkGetPhysicalDeviceXlibPresentationSupportKHR": { + "(VK_KHR_surface)+(VK_KHR_xlib_surface)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-queueFamilyIndex-01315", + "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice" + } + ] + }, + "vkGetPhysicalDeviceDirectFBPresentationSupportEXT": { + "(VK_KHR_surface)+(VK_EXT_directfb_surface)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceDirectFBPresentationSupportEXT-queueFamilyIndex-04119", + "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice" + } + ] + }, + "vkGetPhysicalDeviceScreenPresentationSupportQNX": { + "(VK_KHR_surface)+(VK_QNX_screen_surface)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceScreenPresentationSupportQNX-queueFamilyIndex-04743", + "text": " queueFamilyIndex must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the given physicalDevice" + } + ] + }, + "vkGetPhysicalDeviceSurfaceCapabilitiesKHR": { + "(VK_KHR_surface)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-surface-06211", + "text": " surface must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-surface-parameter", + "text": " surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-pSurfaceCapabilities-parameter", + "text": " pSurfaceCapabilities must be a valid pointer to a VkSurfaceCapabilitiesKHR structure" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-commonparent", + "text": " Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkGetPhysicalDeviceSurfaceCapabilities2KHR": { + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_EXT_full_screen_exclusive+VK_KHR_win32_surface)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pSurfaceInfo-06210", + "text": " pSurfaceInfo->surface must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pNext-02671", + "text": " If a VkSurfaceCapabilitiesFullScreenExclusiveEXT structure is included in the pNext chain of pSurfaceCapabilities, a VkSurfaceFullScreenExclusiveWin32InfoEXT structure must be included in the pNext chain of pSurfaceInfo" + } + ], + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pSurfaceInfo-parameter", + "text": " pSurfaceInfo must be a valid pointer to a valid VkPhysicalDeviceSurfaceInfo2KHR structure" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pSurfaceCapabilities-parameter", + "text": " pSurfaceCapabilities must be a valid pointer to a VkSurfaceCapabilities2KHR structure" + } + ] + }, + "VkPhysicalDeviceSurfaceInfo2KHR": { + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_KHR_win32_surface+VK_EXT_full_screen_exclusive)": [ + { + "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-pNext-02672", + "text": " If the pNext chain includes a VkSurfaceFullScreenExclusiveInfoEXT structure with its fullScreenExclusive member set to VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT, and surface was created using vkCreateWin32SurfaceKHR, a VkSurfaceFullScreenExclusiveWin32InfoEXT structure must be included in the pNext chain" + } + ], + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [ + { + "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR" + }, + { + "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-parameter", + "text": " surface must be a valid VkSurfaceKHR handle" + } + ] + }, + "VkSurfaceFullScreenExclusiveWin32InfoEXT": { + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_EXT_full_screen_exclusive)+(VK_KHR_win32_surface)": [ + { + "vuid": "VUID-VkSurfaceFullScreenExclusiveWin32InfoEXT-hmonitor-02673", + "text": " hmonitor must be a valid HMONITOR" + } + ] + }, + "VkSurfaceCapabilities2KHR": { + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [ + { + "vuid": "VUID-VkSurfaceCapabilities2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR" + }, + { + "vuid": "VUID-VkSurfaceCapabilities2KHR-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkSharedPresentSurfaceCapabilitiesKHR" + }, + { + "vuid": "VUID-VkSurfaceCapabilities2KHR-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + } + ] + }, + "VkSharedPresentSurfaceCapabilitiesKHR": { + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-VkSharedPresentSurfaceCapabilitiesKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR" + } + ] + }, + "vkGetPhysicalDeviceSurfaceCapabilities2EXT": { + "(VK_KHR_surface)+(VK_EXT_display_surface_counter)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-surface-06211", + "text": " surface must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-surface-parameter", + "text": " surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-pSurfaceCapabilities-parameter", + "text": " pSurfaceCapabilities must be a valid pointer to a VkSurfaceCapabilities2EXT structure" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-commonparent", + "text": " Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "VkSurfaceCapabilities2EXT": { + "(VK_KHR_surface)+(VK_EXT_display_surface_counter)": [ + { + "vuid": "VUID-VkSurfaceCapabilities2EXT-supportedSurfaceCounters-01246", + "text": " supportedSurfaceCounters must not include VK_SURFACE_COUNTER_VBLANK_BIT_EXT unless the surface queried is a display surface" + }, + { + "vuid": "VUID-VkSurfaceCapabilities2EXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT" + }, + { + "vuid": "VUID-VkSurfaceCapabilities2EXT-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkGetPhysicalDeviceSurfaceFormatsKHR": { + "(VK_KHR_surface)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-06211", + "text": " surface must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-parameter", + "text": " surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-pSurfaceFormatCount-parameter", + "text": " pSurfaceFormatCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-pSurfaceFormats-parameter", + "text": " If the value referenced by pSurfaceFormatCount is not 0, and pSurfaceFormats is not NULL, pSurfaceFormats must be a valid pointer to an array of pSurfaceFormatCount VkSurfaceFormatKHR structures" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-commonparent", + "text": " Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkGetPhysicalDeviceSurfaceFormats2KHR": { + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceInfo-06210", + "text": " pSurfaceInfo->surface must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceInfo-parameter", + "text": " pSurfaceInfo must be a valid pointer to a valid VkPhysicalDeviceSurfaceInfo2KHR structure" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceFormatCount-parameter", + "text": " pSurfaceFormatCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-pSurfaceFormats-parameter", + "text": " If the value referenced by pSurfaceFormatCount is not 0, and pSurfaceFormats is not NULL, pSurfaceFormats must be a valid pointer to an array of pSurfaceFormatCount VkSurfaceFormat2KHR structures" + } + ] + }, + "VkSurfaceFormat2KHR": { + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)": [ + { + "vuid": "VUID-VkSurfaceFormat2KHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR" + }, + { + "vuid": "VUID-VkSurfaceFormat2KHR-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkGetPhysicalDeviceSurfacePresentModesKHR": { + "(VK_KHR_surface)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-surface-06211", + "text": " surface must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-surface-parameter", + "text": " surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-pPresentModeCount-parameter", + "text": " pPresentModeCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-pPresentModes-parameter", + "text": " If the value referenced by pPresentModeCount is not 0, and pPresentModes is not NULL, pPresentModes must be a valid pointer to an array of pPresentModeCount VkPresentModeKHR values" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-commonparent", + "text": " Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkGetPhysicalDeviceSurfacePresentModes2EXT": { + "(VK_KHR_surface)+(VK_EXT_full_screen_exclusive)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceSurfacePresentModes2EXT-pSurfaceInfo-06210", + "text": " pSurfaceInfo->surface must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" + } + ] + }, + "vkAcquireFullScreenExclusiveModeEXT": { + "(VK_KHR_surface)+(VK_EXT_full_screen_exclusive)": [ + { + "vuid": "VUID-vkAcquireFullScreenExclusiveModeEXT-swapchain-02674", + "text": " swapchain must not be in the retired state" + }, + { + "vuid": "VUID-vkAcquireFullScreenExclusiveModeEXT-swapchain-02675", + "text": " swapchain must be a swapchain created with a VkSurfaceFullScreenExclusiveInfoEXT structure, with fullScreenExclusive set to VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT" + }, + { + "vuid": "VUID-vkAcquireFullScreenExclusiveModeEXT-swapchain-02676", + "text": " swapchain must not currently have exclusive full-screen access" + } + ] + }, + "vkReleaseFullScreenExclusiveModeEXT": { + "(VK_KHR_surface)+(VK_EXT_full_screen_exclusive)": [ + { + "vuid": "VUID-vkReleaseFullScreenExclusiveModeEXT-swapchain-02677", + "text": " swapchain must not be in the retired state" + }, + { + "vuid": "VUID-vkReleaseFullScreenExclusiveModeEXT-swapchain-02678", + "text": " swapchain must be a swapchain created with a VkSurfaceFullScreenExclusiveInfoEXT structure, with fullScreenExclusive set to VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT" + } + ] + }, + "vkGetDeviceGroupPresentCapabilitiesKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkGetDeviceGroupPresentCapabilitiesKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetDeviceGroupPresentCapabilitiesKHR-pDeviceGroupPresentCapabilities-parameter", + "text": " pDeviceGroupPresentCapabilities must be a valid pointer to a VkDeviceGroupPresentCapabilitiesKHR structure" + } + ] + }, + "VkDeviceGroupPresentCapabilitiesKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkDeviceGroupPresentCapabilitiesKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR" + }, + { + "vuid": "VUID-VkDeviceGroupPresentCapabilitiesKHR-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkGetDeviceGroupSurfacePresentModesKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkGetDeviceGroupSurfacePresentModesKHR-surface-06212", + "text": " surface must be supported by all physical devices associated with device, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" + }, + { + "vuid": "VUID-vkGetDeviceGroupSurfacePresentModesKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetDeviceGroupSurfacePresentModesKHR-surface-parameter", + "text": " surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-vkGetDeviceGroupSurfacePresentModesKHR-pModes-parameter", + "text": " pModes must be a valid pointer to a VkDeviceGroupPresentModeFlagsKHR value" + }, + { + "vuid": "VUID-vkGetDeviceGroupSurfacePresentModesKHR-commonparent", + "text": " Both of device, and surface must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkGetDeviceGroupSurfacePresentModes2EXT": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)+(VK_EXT_full_screen_exclusive)": [ + { + "vuid": "VUID-vkGetDeviceGroupSurfacePresentModes2EXT-pSurfaceInfo-06213", + "text": " pSurfaceInfo->surface must be supported by all physical devices associated with device, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" + } + ] + }, + "vkGetPhysicalDevicePresentRectanglesKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkGetPhysicalDevicePresentRectanglesKHR-surface-06211", + "text": " surface must be supported by physicalDevice, as reported by vkGetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism" + }, + { + "vuid": "VUID-vkGetPhysicalDevicePresentRectanglesKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDevicePresentRectanglesKHR-surface-parameter", + "text": " surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-vkGetPhysicalDevicePresentRectanglesKHR-pRectCount-parameter", + "text": " pRectCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDevicePresentRectanglesKHR-pRects-parameter", + "text": " If the value referenced by pRectCount is not 0, and pRects is not NULL, pRects must be a valid pointer to an array of pRectCount VkRect2D structures" + }, + { + "vuid": "VUID-vkGetPhysicalDevicePresentRectanglesKHR-commonparent", + "text": " Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkGetSwapchainStatusKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-vkGetSwapchainStatusKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetSwapchainStatusKHR-swapchain-parameter", + "text": " swapchain must be a valid VkSwapchainKHR handle" + }, + { + "vuid": "VUID-vkGetSwapchainStatusKHR-commonparent", + "text": " Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkCreateSwapchainKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateSwapchainKHR-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)": [ + { + "vuid": "VUID-vkCreateSwapchainKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateSwapchainKHR-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkSwapchainCreateInfoKHR structure" + }, + { + "vuid": "VUID-vkCreateSwapchainKHR-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateSwapchainKHR-pSwapchain-parameter", + "text": " pSwapchain must be a valid pointer to a VkSwapchainKHR handle" + } + ] + }, + "VkSwapchainCreateInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-surface-01270", + "text": " surface must be a surface that is supported by the device as determined using vkGetPhysicalDeviceSurfaceSupportKHR" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-minImageCount-01272", + "text": " minImageCount must be less than or equal to the value returned in the maxImageCount member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface if the returned maxImageCount is not zero" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageFormat-01273", + "text": " imageFormat and imageColorSpace must match the format and colorSpace members, respectively, of one of the VkSurfaceFormatKHR structures returned by vkGetPhysicalDeviceSurfaceFormatsKHR for the surface" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageExtent-01274", + "text": " imageExtent must be between minImageExtent and maxImageExtent, inclusive, where minImageExtent and maxImageExtent are members of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageExtent-01689", + "text": " imageExtent members width and height must both be non-zero" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageArrayLayers-01275", + "text": " imageArrayLayers must be greater than 0 and less than or equal to the maxImageArrayLayers member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01277", + "text": " If imageSharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a valid pointer to an array of queueFamilyIndexCount uint32_t values" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01278", + "text": " If imageSharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-preTransform-01279", + "text": " preTransform must be one of the bits present in the supportedTransforms member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-compositeAlpha-01280", + "text": " compositeAlpha must be one of the bits present in the supportedCompositeAlpha member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-presentMode-01281", + "text": " presentMode must be one of the VkPresentModeKHR values returned by vkGetPhysicalDeviceSurfacePresentModesKHR for the surface" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageFormat-01778", + "text": " The implied image creation parameters of the swapchain must be supported as reported by vkGetPhysicalDeviceImageFormatProperties" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupSwapchainCreateInfoKHR, VkImageFormatListCreateInfo, or VkSwapchainCounterCreateInfoEXT" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-flags-parameter", + "text": " flags must be a valid combination of VkSwapchainCreateFlagBitsKHR values" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-surface-parameter", + "text": " surface must be a valid VkSurfaceKHR handle" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageFormat-parameter", + "text": " imageFormat must be a valid VkFormat value" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageColorSpace-parameter", + "text": " imageColorSpace must be a valid VkColorSpaceKHR value" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageUsage-parameter", + "text": " imageUsage must be a valid combination of VkImageUsageFlagBits values" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageUsage-requiredbitmask", + "text": " imageUsage must not be 0" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageSharingMode-parameter", + "text": " imageSharingMode must be a valid VkSharingMode value" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-preTransform-parameter", + "text": " preTransform must be a valid VkSurfaceTransformFlagBitsKHR value" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-compositeAlpha-parameter", + "text": " compositeAlpha must be a valid VkCompositeAlphaFlagBitsKHR value" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-presentMode-parameter", + "text": " presentMode must be a valid VkPresentModeKHR value" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parent", + "text": " If oldSwapchain is a valid handle, it must have been created, allocated, or retrieved from surface" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-commonparent", + "text": " Both of oldSwapchain, and surface that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkInstance" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+!(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-minImageCount-01271", + "text": " minImageCount must be greater than or equal to the value returned in the minImageCount member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageUsage-01276", + "text": " imageUsage must be a subset of the supported usage flags present in the supportedUsageFlags member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-presentMode-02839", + "text": " If presentMode is not VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR nor VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR, then minImageCount must be greater than or equal to the value returned in the minImageCount member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-minImageCount-01383", + "text": " minImageCount must be 1 if presentMode is either VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR or VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-presentMode-01427", + "text": " If presentMode is VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR or VK_PRESENT_MODE_FIFO_RELAXED_KHR, imageUsage must be a subset of the supported usage flags present in the supportedUsageFlags member of the VkSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR for surface" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageUsage-01384", + "text": " If presentMode is VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR or VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR, imageUsage must be a subset of the supported usage flags present in the sharedPresentSupportedUsageFlags member of the VkSharedPresentSurfaceCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilities2KHR for surface" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+!(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01393", + "text": " If imageSharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the physicalDevice that was used to create device" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01428", + "text": " If imageSharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-physicalDeviceCount-01429", + "text": " If the logical device was created with VkDeviceGroupDeviceCreateInfo::physicalDeviceCount equal to 1, flags must not contain VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-flags-05072", + "text": " flags must not contain VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-oldSwapchain-01933", + "text": " If oldSwapchain is not VK_NULL_HANDLE, oldSwapchain must be a non-retired swapchain associated with native window referred to by surface" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-oldSwapchain-05073", + "text": " oldSwapchain must be VK_NULL_HANDLE" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_swapchain_mutable_format)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-flags-03168", + "text": " If flags contains VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR then the pNext chain must include a VkImageFormatListCreateInfo structure with a viewFormatCount greater than zero and pViewFormats must have an element equal to imageFormat" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-pNext-04099", + "text": " If a VkImageFormatListCreateInfo structure was included in the pNext chain and VkImageFormatListCreateInfo::viewFormatCount is not zero then all of the formats in VkImageFormatListCreateInfo::pViewFormats must be compatible with the format as described in the compatibility table" + }, + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-flags-04100", + "text": " If flags does not contain VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR and the pNext chain include a VkImageFormatListCreateInfo structure then VkImageFormatListCreateInfo::viewFormatCount must be 0 or 1" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_surface_protected_capabilities)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-flags-03187", + "text": " If flags contains VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR, then VkSurfaceProtectedCapabilitiesKHR::supportsProtected must be VK_TRUE in the VkSurfaceProtectedCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilities2KHR for surface" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_full_screen_exclusive+VK_KHR_win32_surface)": [ + { + "vuid": "VUID-VkSwapchainCreateInfoKHR-pNext-02679", + "text": " If the pNext chain includes a VkSurfaceFullScreenExclusiveInfoEXT structure with its fullScreenExclusive member set to VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT, and surface was created using vkCreateWin32SurfaceKHR, a VkSurfaceFullScreenExclusiveWin32InfoEXT structure must be included in the pNext chain" + } + ] + }, + "VkDeviceGroupSwapchainCreateInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkDeviceGroupSwapchainCreateInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR" + }, + { + "vuid": "VUID-VkDeviceGroupSwapchainCreateInfoKHR-modes-parameter", + "text": " modes must be a valid combination of VkDeviceGroupPresentModeFlagBitsKHR values" + }, + { + "vuid": "VUID-VkDeviceGroupSwapchainCreateInfoKHR-modes-requiredbitmask", + "text": " modes must not be 0" + } + ] + }, + "VkSwapchainDisplayNativeHdrCreateInfoAMD": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_AMD_display_native_hdr)": [ + { + "vuid": "VUID-VkSwapchainDisplayNativeHdrCreateInfoAMD-localDimmingEnable-04449", + "text": " It is only valid to set localDimmingEnable to VK_TRUE if VkDisplayNativeHdrSurfaceCapabilitiesAMD::localDimmingSupport is supported" + } + ] + }, + "vkSetLocalDimmingAMD": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_AMD_display_native_hdr)": [ + { + "vuid": "VUID-vkSetLocalDimmingAMD-localDimmingSupport-04618", + "text": " VkDisplayNativeHdrSurfaceCapabilitiesAMD::localDimmingSupport must be supported" + } + ] + }, + "VkSwapchainCounterCreateInfoEXT": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_display_control)": [ + { + "vuid": "VUID-VkSwapchainCounterCreateInfoEXT-surfaceCounters-01244", + "text": " The bits in surfaceCounters must be supported by VkSwapchainCreateInfoKHR::surface, as reported by vkGetPhysicalDeviceSurfaceCapabilities2EXT" + }, + { + "vuid": "VUID-VkSwapchainCounterCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkSwapchainCounterCreateInfoEXT-surfaceCounters-parameter", + "text": " surfaceCounters must be a valid combination of VkSurfaceCounterFlagBitsEXT values" + } + ] + }, + "vkGetSwapchainCounterEXT": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_display_control)": [ + { + "vuid": "VUID-vkGetSwapchainCounterEXT-swapchain-01245", + "text": " One or more present commands on swapchain must have been processed by the presentation engine" + }, + { + "vuid": "VUID-vkGetSwapchainCounterEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetSwapchainCounterEXT-swapchain-parameter", + "text": " swapchain must be a valid VkSwapchainKHR handle" + }, + { + "vuid": "VUID-vkGetSwapchainCounterEXT-counter-parameter", + "text": " counter must be a valid VkSurfaceCounterFlagBitsEXT value" + }, + { + "vuid": "VUID-vkGetSwapchainCounterEXT-pCounterValue-parameter", + "text": " pCounterValue must be a valid pointer to a uint64_t value" + }, + { + "vuid": "VUID-vkGetSwapchainCounterEXT-commonparent", + "text": " Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkDestroySwapchainKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroySwapchainKHR-swapchain-01282", + "text": " All uses of presentable images acquired from swapchain must have completed execution" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+!(VKSC_VERSION_1_0)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroySwapchainKHR-swapchain-01283", + "text": " If VkAllocationCallbacks were provided when swapchain was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroySwapchainKHR-swapchain-01284", + "text": " If no VkAllocationCallbacks were provided when swapchain was created, pAllocator must be NULL" + } + ] + }, + "vkCreateSharedSwapchainsKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreateSharedSwapchainsKHR-device-05068", + "text": " The number of {objectnameplural} currently allocated from device plus {objectcount} must be less than or equal to the total number of {objectnameplural} requested via VkDeviceObjectReservationCreateInfo::pname:{objectnamecamelcase}RequestCount specified when device was created" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)": [ + { + "vuid": "VUID-vkCreateSharedSwapchainsKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateSharedSwapchainsKHR-pCreateInfos-parameter", + "text": " pCreateInfos must be a valid pointer to an array of swapchainCount valid VkSwapchainCreateInfoKHR structures" + }, + { + "vuid": "VUID-vkCreateSharedSwapchainsKHR-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateSharedSwapchainsKHR-pSwapchains-parameter", + "text": " pSwapchains must be a valid pointer to an array of swapchainCount VkSwapchainKHR handles" + }, + { + "vuid": "VUID-vkCreateSharedSwapchainsKHR-swapchainCount-arraylength", + "text": " swapchainCount must be greater than 0" + } + ] + }, + "vkGetSwapchainImagesKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)": [ + { + "vuid": "VUID-vkGetSwapchainImagesKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetSwapchainImagesKHR-swapchain-parameter", + "text": " swapchain must be a valid VkSwapchainKHR handle" + }, + { + "vuid": "VUID-vkGetSwapchainImagesKHR-pSwapchainImageCount-parameter", + "text": " pSwapchainImageCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetSwapchainImagesKHR-pSwapchainImages-parameter", + "text": " If the value referenced by pSwapchainImageCount is not 0, and pSwapchainImages is not NULL, pSwapchainImages must be a valid pointer to an array of pSwapchainImageCount VkImage handles" + }, + { + "vuid": "VUID-vkGetSwapchainImagesKHR-commonparent", + "text": " Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "vkAcquireNextImageKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)": [ + { + "vuid": "VUID-vkAcquireNextImageKHR-swapchain-01285", + "text": " swapchain must not be in the retired state" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-semaphore-01286", + "text": " If semaphore is not VK_NULL_HANDLE it must be unsignaled" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-semaphore-01779", + "text": " If semaphore is not VK_NULL_HANDLE it must not have any uncompleted signal or wait operations pending" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-fence-01287", + "text": " If fence is not VK_NULL_HANDLE it must be unsignaled and must not be associated with any other queue command that has not yet completed execution on that queue" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-semaphore-01780", + "text": " semaphore and fence must not both be equal to VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-swapchain-01802", + "text": " If the number of currently acquired images is greater than the difference between the number of images in swapchain and the value of VkSurfaceCapabilitiesKHR::minImageCount as returned by a call to vkGetPhysicalDeviceSurfaceCapabilities2KHR with the surface used to create swapchain, timeout must not be UINT64_MAX" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-swapchain-parameter", + "text": " swapchain must be a valid VkSwapchainKHR handle" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-semaphore-parameter", + "text": " If semaphore is not VK_NULL_HANDLE, semaphore must be a valid VkSemaphore handle" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-fence-parameter", + "text": " If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-pImageIndex-parameter", + "text": " pImageIndex must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-semaphore-parent", + "text": " If semaphore is a valid handle, it must have been created, allocated, or retrieved from device" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-fence-parent", + "text": " If fence is a valid handle, it must have been created, allocated, or retrieved from device" + }, + { + "vuid": "VUID-vkAcquireNextImageKHR-commonparent", + "text": " Both of device, and swapchain that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkInstance" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-vkAcquireNextImageKHR-semaphore-03265", + "text": " semaphore must have a VkSemaphoreType of VK_SEMAPHORE_TYPE_BINARY" + } + ] + }, + "vkAcquireNextImage2KHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-vkAcquireNextImage2KHR-swapchain-01803", + "text": " If the number of currently acquired images is greater than the difference between the number of images in the swapchain member of pAcquireInfo and the value of VkSurfaceCapabilitiesKHR::minImageCount as returned by a call to vkGetPhysicalDeviceSurfaceCapabilities2KHR with the surface used to create swapchain, the timeout member of pAcquireInfo must not be UINT64_MAX" + }, + { + "vuid": "VUID-vkAcquireNextImage2KHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkAcquireNextImage2KHR-pAcquireInfo-parameter", + "text": " pAcquireInfo must be a valid pointer to a valid VkAcquireNextImageInfoKHR structure" + }, + { + "vuid": "VUID-vkAcquireNextImage2KHR-pImageIndex-parameter", + "text": " pImageIndex must be a valid pointer to a uint32_t value" + } + ] + }, + "VkAcquireNextImageInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-swapchain-01675", + "text": " swapchain must not be in the retired state" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-semaphore-01288", + "text": " If semaphore is not VK_NULL_HANDLE it must be unsignaled" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-semaphore-01781", + "text": " If semaphore is not VK_NULL_HANDLE it must not have any uncompleted signal or wait operations pending" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-fence-01289", + "text": " If fence is not VK_NULL_HANDLE it must be unsignaled and must not be associated with any other queue command that has not yet completed execution on that queue" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-semaphore-01782", + "text": " semaphore and fence must not both be equal to VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-deviceMask-01290", + "text": " deviceMask must be a valid device mask" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-deviceMask-01291", + "text": " deviceMask must not be zero" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-swapchain-parameter", + "text": " swapchain must be a valid VkSwapchainKHR handle" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-semaphore-parameter", + "text": " If semaphore is not VK_NULL_HANDLE, semaphore must be a valid VkSemaphore handle" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-fence-parameter", + "text": " If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle" + }, + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-commonparent", + "text": " Each of fence, semaphore, and swapchain that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkInstance" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)+(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-VkAcquireNextImageInfoKHR-semaphore-03266", + "text": " semaphore must have a VkSemaphoreType of VK_SEMAPHORE_TYPE_BINARY" + } + ] + }, + "vkQueuePresentKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)": [ + { + "vuid": "VUID-vkQueuePresentKHR-pSwapchains-01292", + "text": " Each element of pSwapchains member of pPresentInfo must be a swapchain that is created for a surface for which presentation is supported from queue as determined using a call to vkGetPhysicalDeviceSurfaceSupportKHR" + }, + { + "vuid": "VUID-vkQueuePresentKHR-pWaitSemaphores-01294", + "text": " When a semaphore wait operation referring to a binary semaphore defined by the elements of the pWaitSemaphores member of pPresentInfo executes on queue, there must be no other queues waiting on the same semaphore" + }, + { + "vuid": "VUID-vkQueuePresentKHR-pWaitSemaphores-01295", + "text": " All elements of the pWaitSemaphores member of pPresentInfo must be semaphores that are signaled, or have semaphore signal operations previously submitted for execution" + }, + { + "vuid": "VUID-vkQueuePresentKHR-queue-parameter", + "text": " queue must be a valid VkQueue handle" + }, + { + "vuid": "VUID-vkQueuePresentKHR-pPresentInfo-parameter", + "text": " pPresentInfo must be a valid pointer to a valid VkPresentInfoKHR structure" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)": [ + { + "vuid": "VUID-vkQueuePresentKHR-pSwapchains-01293", + "text": " If more than one member of pSwapchains was created from a display surface, all display surfaces referenced that refer to the same display must use the same display mode" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-vkQueuePresentKHR-pWaitSemaphores-03267", + "text": " All elements of the pWaitSemaphores member of pPresentInfo must be created with a VkSemaphoreType of VK_SEMAPHORE_TYPE_BINARY" + }, + { + "vuid": "VUID-vkQueuePresentKHR-pWaitSemaphores-03268", + "text": " All elements of the pWaitSemaphores member of pPresentInfo must reference a semaphore signal operation that has been submitted for execution and any semaphore signal operations on which it depends (if any) must have also been submitted for execution" + } + ] + }, + "VkPresentInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+!(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-VkPresentInfoKHR-pImageIndices-01296", + "text": " Each element of pImageIndices must be the index of a presentable image acquired from the swapchain specified by the corresponding element of the pSwapchains array, and the presented image subresource must be in the VK_IMAGE_LAYOUT_PRESENT_SRC_KHR layout at the time the operation is executed on a VkDevice" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_shared_presentable_image)": [ + { + "vuid": "VUID-VkPresentInfoKHR-pImageIndices-01430", + "text": " Each element of pImageIndices must be the index of a presentable image acquired from the swapchain specified by the corresponding element of the pSwapchains array, and the presented image subresource must be in the VK_IMAGE_LAYOUT_PRESENT_SRC_KHR or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR layout at the time the operation is executed on a VkDevice" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_present_id)": [ + { + "vuid": "VUID-VkPresentInfoKHR-pNext-06235", + "text": " If a VkPresentIdKHR structure is included in the pNext chain, and the presentId feature is not enabled, each presentIds entry in that structure must be NULL" + } + ], + "(VK_KHR_surface)+(VK_KHR_swapchain)": [ + { + "vuid": "VUID-VkPresentInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PRESENT_INFO_KHR" + }, + { + "vuid": "VUID-VkPresentInfoKHR-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupPresentInfoKHR, VkDisplayPresentInfoKHR, or VkPresentRegionsKHR" + }, + { + "vuid": "VUID-VkPresentInfoKHR-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkPresentInfoKHR-pWaitSemaphores-parameter", + "text": " If waitSemaphoreCount is not 0, pWaitSemaphores must be a valid pointer to an array of waitSemaphoreCount valid VkSemaphore handles" + }, + { + "vuid": "VUID-VkPresentInfoKHR-pSwapchains-parameter", + "text": " pSwapchains must be a valid pointer to an array of swapchainCount valid VkSwapchainKHR handles" + }, + { + "vuid": "VUID-VkPresentInfoKHR-pImageIndices-parameter", + "text": " pImageIndices must be a valid pointer to an array of swapchainCount uint32_t values" + }, + { + "vuid": "VUID-VkPresentInfoKHR-pResults-parameter", + "text": " If pResults is not NULL, pResults must be a valid pointer to an array of swapchainCount VkResult values" + }, + { + "vuid": "VUID-VkPresentInfoKHR-swapchainCount-arraylength", + "text": " swapchainCount must be greater than 0" + }, + { + "vuid": "VUID-VkPresentInfoKHR-commonparent", + "text": " Both of the elements of pSwapchains, and the elements of pWaitSemaphores that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "VkPresentRegionsKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_incremental_present)": [ + { + "vuid": "VUID-VkPresentRegionsKHR-swapchainCount-01260", + "text": " swapchainCount must be the same value as VkPresentInfoKHR::swapchainCount, where VkPresentInfoKHR is included in the pNext chain of this VkPresentRegionsKHR structure" + }, + { + "vuid": "VUID-VkPresentRegionsKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR" + }, + { + "vuid": "VUID-VkPresentRegionsKHR-pRegions-parameter", + "text": " If pRegions is not NULL, pRegions must be a valid pointer to an array of swapchainCount valid VkPresentRegionKHR structures" + }, + { + "vuid": "VUID-VkPresentRegionsKHR-swapchainCount-arraylength", + "text": " swapchainCount must be greater than 0" + } + ] + }, + "VkPresentRegionKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_incremental_present)": [ + { + "vuid": "VUID-VkPresentRegionKHR-pRectangles-parameter", + "text": " If rectangleCount is not 0, and pRectangles is not NULL, pRectangles must be a valid pointer to an array of rectangleCount valid VkRectLayerKHR structures" + } + ] + }, + "VkRectLayerKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_incremental_present)": [ + { + "vuid": "VUID-VkRectLayerKHR-offset-04864", + "text": " The sum of offset and extent, after being transformed according to the preTransform member of the VkSwapchainCreateInfoKHR structure, must be no greater than the imageExtent member of the VkSwapchainCreateInfoKHR structure passed to vkCreateSwapchainKHR" + }, + { + "vuid": "VUID-VkRectLayerKHR-layer-01262", + "text": " layer must be less than the imageArrayLayers member of the VkSwapchainCreateInfoKHR structure passed to vkCreateSwapchainKHR" + } + ] + }, + "VkDisplayPresentInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_display_swapchain)": [ + { + "vuid": "VUID-VkDisplayPresentInfoKHR-srcRect-01257", + "text": " srcRect must specify a rectangular region that is a subset of the image being presented" + }, + { + "vuid": "VUID-VkDisplayPresentInfoKHR-dstRect-01258", + "text": " dstRect must specify a rectangular region that is a subset of the visibleRegion parameter of the display mode the swapchain being presented uses" + }, + { + "vuid": "VUID-VkDisplayPresentInfoKHR-persistentContent-01259", + "text": " If the persistentContent member of the VkDisplayPropertiesKHR structure returned by vkGetPhysicalDeviceDisplayPropertiesKHR for the display the present operation targets is VK_FALSE, then persistent must be VK_FALSE" + }, + { + "vuid": "VUID-VkDisplayPresentInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR" + } + ] + }, + "VkDeviceGroupPresentInfoKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkDeviceGroupPresentInfoKHR-swapchainCount-01297", + "text": " swapchainCount must equal 0 or VkPresentInfoKHR::swapchainCount" + }, + { + "vuid": "VUID-VkDeviceGroupPresentInfoKHR-mode-01298", + "text": " If mode is VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR, then each element of pDeviceMasks must have exactly one bit set, and the corresponding element of VkDeviceGroupPresentCapabilitiesKHR::presentMask must be non-zero" + }, + { + "vuid": "VUID-VkDeviceGroupPresentInfoKHR-mode-01299", + "text": " If mode is VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR, then each element of pDeviceMasks must have exactly one bit set, and some physical device in the logical device must include that bit in its VkDeviceGroupPresentCapabilitiesKHR::presentMask" + }, + { + "vuid": "VUID-VkDeviceGroupPresentInfoKHR-mode-01300", + "text": " If mode is VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR, then each element of pDeviceMasks must have a value for which all set bits are set in one of the elements of VkDeviceGroupPresentCapabilitiesKHR::presentMask" + }, + { + "vuid": "VUID-VkDeviceGroupPresentInfoKHR-mode-01301", + "text": " If mode is VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR, then for each bit set in each element of pDeviceMasks, the corresponding element of VkDeviceGroupPresentCapabilitiesKHR::presentMask must be non-zero" + }, + { + "vuid": "VUID-VkDeviceGroupPresentInfoKHR-pDeviceMasks-01302", + "text": " The value of each element of pDeviceMasks must be equal to the device mask passed in VkAcquireNextImageInfoKHR::deviceMask when the image index was last acquired" + }, + { + "vuid": "VUID-VkDeviceGroupPresentInfoKHR-mode-01303", + "text": " mode must have exactly one bit set, and that bit must have been included in VkDeviceGroupSwapchainCreateInfoKHR::modes" + }, + { + "vuid": "VUID-VkDeviceGroupPresentInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR" + }, + { + "vuid": "VUID-VkDeviceGroupPresentInfoKHR-pDeviceMasks-parameter", + "text": " If swapchainCount is not 0, pDeviceMasks must be a valid pointer to an array of swapchainCount uint32_t values" + }, + { + "vuid": "VUID-VkDeviceGroupPresentInfoKHR-mode-parameter", + "text": " mode must be a valid VkDeviceGroupPresentModeFlagBitsKHR value" + } + ] + }, + "VkPresentTimesInfoGOOGLE": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GOOGLE_display_timing)": [ + { + "vuid": "VUID-VkPresentTimesInfoGOOGLE-swapchainCount-01247", + "text": " swapchainCount must be the same value as VkPresentInfoKHR::swapchainCount, where VkPresentInfoKHR is included in the pNext chain of this VkPresentTimesInfoGOOGLE structure" + } + ] + }, + "VkPresentIdKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_present_id)": [ + { + "vuid": "VUID-VkPresentIdKHR-swapchainCount-04998", + "text": " swapchainCount must be the same value as VkPresentInfoKHR::swapchainCount, where this VkPresentIdKHR is in the pNext chain of the VkPresentInfoKHR structure" + }, + { + "vuid": "VUID-VkPresentIdKHR-presentIds-04999", + "text": " Each presentIds entry must be greater than any previous presentIds entry passed for the associated pSwapchains entry" + } + ] + }, + "vkWaitForPresentKHR": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_KHR_present_id)+(VK_KHR_present_wait)": [ + { + "vuid": "VUID-vkWaitForPresentKHR-swapchain-04997", + "text": " swapchain must not be in the retired state" + }, + { + "vuid": "VUID-vkWaitForPresentKHR-presentWait-06234", + "text": " The presentWait feature must be enabled" + } + ] + }, + "VkPresentFrameTokenGGP": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_GGP_frame_token)": [ + { + "vuid": "VUID-VkPresentFrameTokenGGP-frameToken-02680", + "text": " frameToken must be a valid GgpFrameToken" + } + ] + }, + "vkSetHdrMetadataEXT": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_hdr_metadata)": [ + { + "vuid": "VUID-vkSetHdrMetadataEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkSetHdrMetadataEXT-pSwapchains-parameter", + "text": " pSwapchains must be a valid pointer to an array of swapchainCount valid VkSwapchainKHR handles" + }, + { + "vuid": "VUID-vkSetHdrMetadataEXT-pMetadata-parameter", + "text": " pMetadata must be a valid pointer to an array of swapchainCount valid VkHdrMetadataEXT structures" + }, + { + "vuid": "VUID-vkSetHdrMetadataEXT-swapchainCount-arraylength", + "text": " swapchainCount must be greater than 0" + }, + { + "vuid": "VUID-vkSetHdrMetadataEXT-commonparent", + "text": " Both of device, and the elements of pSwapchains must have been created, allocated, or retrieved from the same VkInstance" + } + ] + }, + "VkHdrMetadataEXT": { + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_hdr_metadata)": [ + { + "vuid": "VUID-VkHdrMetadataEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_HDR_METADATA_EXT" + }, + { + "vuid": "VUID-VkHdrMetadataEXT-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkDestroyDeferredOperationKHR": { + "(VK_KHR_deferred_host_operations)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyDeferredOperationKHR-operation-03434", + "text": " If VkAllocationCallbacks were provided when operation was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyDeferredOperationKHR-operation-03435", + "text": " If no VkAllocationCallbacks were provided when operation was created, pAllocator must be NULL" + } + ], + "(VK_KHR_deferred_host_operations)": [ + { + "vuid": "VUID-vkDestroyDeferredOperationKHR-operation-03436", + "text": " operation must be completed" + } + ] + }, + "vkCreatePrivateDataSlotEXT": { + "(VK_EXT_private_data)": [ + { + "vuid": "VUID-vkCreatePrivateDataSlotEXT-privateData-04564", + "text": " The privateData feature must be enabled" + } + ], + "(VK_EXT_private_data)+(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkCreatePrivateDataSlotEXT-device-05000", + "text": " The number of private data slots currently allocated from device plus 1 must be less than or equal to the total number of private data slots requested via VkDevicePrivateDataCreateInfoEXT::privateDataSlotRequestCount when device was created" + } + ] + }, + "vkDestroyPrivateDataSlotEXT": { + "(VK_EXT_private_data)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyPrivateDataSlotEXT-privateDataSlot-04062", + "text": " If VkAllocationCallbacks were provided when privateDataSlot was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyPrivateDataSlotEXT-privateDataSlot-04063", + "text": " If no VkAllocationCallbacks were provided when privateDataSlot was created, pAllocator must be NULL" + } + ] + }, + "vkSetPrivateDataEXT": { + "(VK_EXT_private_data)": [ + { + "vuid": "VUID-vkSetPrivateDataEXT-objectHandle-04016", + "text": " objectHandle must be device or a child of device" + }, + { + "vuid": "VUID-vkSetPrivateDataEXT-objectHandle-04017", + "text": " objectHandle must be a valid handle to an object of type objectType" + } + ] + }, + "vkGetPrivateDataEXT": { + "(VK_EXT_private_data)": [ + { + "vuid": "VUID-vkGetPrivateDataEXT-objectType-04018", + "text": " objectType must be VK_OBJECT_TYPE_DEVICE, or an object type whose parent is VkDevice" + } + ] + }, + "vkCmdBuildAccelerationStructureNV": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-geometryCount-02241", + "text": " geometryCount must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxGeometryCount" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-dst-02488", + "text": " dst must have been created with compatible VkAccelerationStructureInfoNV where VkAccelerationStructureInfoNV::type and VkAccelerationStructureInfoNV::flags are identical, VkAccelerationStructureInfoNV::instanceCount and VkAccelerationStructureInfoNV::geometryCount for dst are greater than or equal to the build size and each geometry in VkAccelerationStructureInfoNV::pGeometries for dst has greater than or equal to the number of vertices, indices, and AABBs" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-update-02489", + "text": " If update is VK_TRUE, src must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-update-02490", + "text": " If update is VK_TRUE, src must have previously been constructed with VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV set in VkAccelerationStructureInfoNV::flags in the original build" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-update-02491", + "text": " If update is VK_FALSE, the size member of the VkMemoryRequirements structure returned from a call to vkGetAccelerationStructureMemoryRequirementsNV with VkAccelerationStructureMemoryRequirementsInfoNV::accelerationStructure set to dst and VkAccelerationStructureMemoryRequirementsInfoNV::type set to VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV must be less than or equal to the size of scratch minus scratchOffset" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-update-02492", + "text": " If update is VK_TRUE, the size member of the VkMemoryRequirements structure returned from a call to vkGetAccelerationStructureMemoryRequirementsNV with VkAccelerationStructureMemoryRequirementsInfoNV::accelerationStructure set to dst and VkAccelerationStructureMemoryRequirementsInfoNV::type set to VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV must be less than or equal to the size of scratch minus scratchOffset" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-scratch-03522", + "text": " scratch must have been created with VK_BUFFER_USAGE_RAY_TRACING_BIT_NV usage flag" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-instanceData-03523", + "text": " If instanceData is not VK_NULL_HANDLE, instanceData must have been created with VK_BUFFER_USAGE_RAY_TRACING_BIT_NV usage flag" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-accelerationStructureReference-03786", + "text": " Each VkAccelerationStructureInstanceKHR::accelerationStructureReference value in instanceData must be a valid device address containing a value obtained from vkGetAccelerationStructureHandleNV" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-update-03524", + "text": " If update is VK_TRUE, then objects that were previously active must not be made inactive as per Inactive Primitives and Instances" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-update-03525", + "text": " If update is VK_TRUE, then objects that were previously inactive must not be made active as per Inactive Primitives and Instances" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructureNV-update-03526", + "text": " If update is VK_TRUE, the src and dst objects must either be the same object or not have any memory aliasing" + } + ] + }, + "vkCmdBuildAccelerationStructuresKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-mode-04628", + "text": " The mode member of each element of pInfos must be a valid VkBuildAccelerationStructureModeKHR value" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-srcAccelerationStructure-04629", + "text": " If the srcAccelerationStructure member of any element of pInfos is not VK_NULL_HANDLE, the srcAccelerationStructure member must be a valid VkAccelerationStructureKHR handle" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-04630", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, its srcAccelerationStructure member must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03403", + "text": " The srcAccelerationStructure member of any element of pInfos must not be the same acceleration structure as the dstAccelerationStructure member of any other element of pInfos" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-dstAccelerationStructure-03698", + "text": " The dstAccelerationStructure member of any element of pInfos must not be the same acceleration structure as the dstAccelerationStructure member of any other element of pInfos" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-dstAccelerationStructure-03800", + "text": " The dstAccelerationStructure member of any element of pInfos must be a valid VkAccelerationStructureKHR handle" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03699", + "text": " For each element of pInfos, if its type member is VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, its dstAccelerationStructure member must have been created with a value of VkAccelerationStructureCreateInfoKHR::type equal to either VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR or VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03700", + "text": " For each element of pInfos, if its type member is VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR, its dstAccelerationStructure member must have been created with a value of VkAccelerationStructureCreateInfoKHR::type equal to either VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR or VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03663", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, inactive primitives in its srcAccelerationStructure member must not be made active" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03664", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, active primitives in its srcAccelerationStructure member must not be made inactive" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-None-03407", + "text": " The dstAccelerationStructure member of any element of pInfos must not be referenced by the geometry.instances.data member of any element of pGeometries or ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR in any other element of pInfos" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-dstAccelerationStructure-03701", + "text": " The range of memory backing the dstAccelerationStructure member of any element of pInfos that is accessed by this command must not overlap the memory backing the srcAccelerationStructure member of any other element of pInfos with a mode equal to VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, which is accessed by this command" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-dstAccelerationStructure-03702", + "text": " The range of memory backing the dstAccelerationStructure member of any element of pInfos that is accessed by this command must not overlap the memory backing the dstAccelerationStructure member of any other element of pInfos, which is accessed by this command" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-dstAccelerationStructure-03703", + "text": " The range of memory backing the dstAccelerationStructure member of any element of pInfos that is accessed by this command must not overlap the memory backing the scratchData member of any element of pInfos (including the same element), which is accessed by this command" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-scratchData-03704", + "text": " The range of memory backing the scratchData member of any element of pInfos that is accessed by this command must not overlap the memory backing the scratchData member of any other element of pInfos, which is accessed by this command" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-scratchData-03705", + "text": " The range of memory backing the scratchData member of any element of pInfos that is accessed by this command must not overlap the memory backing the srcAccelerationStructure member of any element of pInfos with a mode equal to VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR (including the same element), which is accessed by this command" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-dstAccelerationStructure-03706", + "text": " The range of memory backing the dstAccelerationStructure member of any element of pInfos that is accessed by this command must not overlap the memory backing any acceleration structure referenced by the geometry.instances.data member of any element of pGeometries or ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR in any other element of pInfos, which is accessed by this command" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03667", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, its srcAccelerationStructure member must have previously been constructed with VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR set in VkAccelerationStructureBuildGeometryInfoKHR::flags in the build" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03668", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, its srcAccelerationStructure and dstAccelerationStructure members must either be the same VkAccelerationStructureKHR, or not have any memory aliasing" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03758", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, its geometryCount member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03759", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, its flags member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03760", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, its type member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03761", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, its geometryType member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03762", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, its flags member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03763", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, if geometryType is VK_GEOMETRY_TYPE_TRIANGLES_KHR, its geometry.triangles.vertexFormat member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03764", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, if geometryType is VK_GEOMETRY_TYPE_TRIANGLES_KHR, its geometry.triangles.maxVertex member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03765", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, if geometryType is VK_GEOMETRY_TYPE_TRIANGLES_KHR, its geometry.triangles.indexType member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03766", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, if geometryType is VK_GEOMETRY_TYPE_TRIANGLES_KHR, if its geometry.triangles.transformData address was NULL when srcAccelerationStructure was last built, then it must be NULL" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03767", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, if geometryType is VK_GEOMETRY_TYPE_TRIANGLES_KHR, if its geometry.triangles.transformData address was not NULL when srcAccelerationStructure was last built, then it must not be NULL" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03768", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, if geometryType is VK_GEOMETRY_TYPE_TRIANGLES_KHR, and geometry.triangles.indexType is not VK_INDEX_TYPE_NONE_KHR, then the value of each index referenced must be the same as the corresponding index value when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-primitiveCount-03769", + "text": " For each VkAccelerationStructureBuildRangeInfoKHR referenced by this command, its primitiveCount member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-firstVertex-03770", + "text": " For each VkAccelerationStructureBuildRangeInfoKHR referenced by this command, if the corresponding geometry uses indices, its firstVertex member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03801", + "text": " For each element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR, the corresponding {maxinstancecheck} must be less than or equal to VkPhysicalDeviceAccelerationStructurePropertiesKHR::maxInstanceCount" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03707", + "text": " For each element of pInfos, the buffer used to create its dstAccelerationStructure member must be bound to device memory" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03708", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR the buffer used to create its srcAccelerationStructure member must be bound to device memory" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03709", + "text": " For each element of pInfos, the buffer used to create each acceleration structure referenced by the geometry.instances.data member of any element of pGeometries or ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR must be bound to device memory" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03671", + "text": " If pInfos[i].mode is VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR, all addresses between pInfos[i].scratchData.deviceAddress and pInfos[i].scratchData.deviceAddress + N - 1 must be in the buffer device address range of the same buffer, where N is given by the buildScratchSize member of the VkAccelerationStructureBuildSizesInfoKHR structure returned from a call to vkGetAccelerationStructureBuildSizesKHR with an identical VkAccelerationStructureBuildGeometryInfoKHR structure and primitive count" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03672", + "text": " If pInfos[i].mode is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, all addresses between pInfos[i].scratchData.deviceAddress and pInfos[i].scratchData.deviceAddress + N - 1 must be in the buffer device address range of the same buffer, where N is given by the updateScratchSize member of the VkAccelerationStructureBuildSizesInfoKHR structure returned from a call to vkGetAccelerationStructureBuildSizesKHR with an identical VkAccelerationStructureBuildGeometryInfoKHR structure and primitive count" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-geometry-03673", + "text": " The buffers from which the buffer device addresses for all of the geometry.triangles.vertexData, geometry.triangles.indexData, geometry.triangles.transformData, geometry.aabbs.data, and geometry.instances.data members of all pInfos[i].pGeometries and pInfos[i].ppGeometries are queried must have been created with the VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR usage flag" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03674", + "text": " The buffer from which the buffer device address pInfos[i].scratchData.deviceAddress is queried must have been created with VK_BUFFER_USAGE_STORAGE_BUFFER_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03802", + "text": " For each element of pInfos, its scratchData.deviceAddress member must be a valid device address obtained from vkGetBufferDeviceAddress" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03803", + "text": " For each element of pInfos, if scratchData.deviceAddress is the address of a non-sparse buffer then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03710", + "text": " For each element of pInfos, its scratchData.deviceAddress member must be a multiple of VkPhysicalDeviceAccelerationStructurePropertiesKHR::minAccelerationStructureScratchOffsetAlignment" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03804", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, geometry.triangles.vertexData.deviceAddress must be a valid device address obtained from vkGetBufferDeviceAddress" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03805", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, if geometry.triangles.vertexData.deviceAddress is the address of a non-sparse buffer then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03711", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, geometry.triangles.vertexData.deviceAddress must be aligned to the size in bytes of the smallest component of the format in vertexFormat" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03806", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, if geometry.triangles.indexType is not VK_INDEX_TYPE_NONE_KHR, geometry.triangles.indexData.deviceAddress must be a valid device address obtained from vkGetBufferDeviceAddress" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03807", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, if geometry.triangles.indexType is not VK_INDEX_TYPE_NONE_KHR, if geometry.triangles.indexData.deviceAddress is the address of a non-sparse buffer then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03712", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, and with geometry.triangles.indexType not equal to VK_INDEX_TYPE_NONE_KHR, geometry.triangles.indexData.deviceAddress must be aligned to the size in bytes of the type in indexType" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03808", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, if geometry.triangles.transformData.deviceAddress is not 0, it must be a valid device address obtained from vkGetBufferDeviceAddress" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03809", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, if geometry.triangles.transformData.deviceAddress is the address of a non-sparse buffer then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03810", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, if geometry.triangles.transformData.deviceAddress is not 0, it must be aligned to 16 bytes" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03811", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_AABBS_KHR, geometry.aabbs.data.deviceAddress must be a valid device address obtained from vkGetBufferDeviceAddress" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03812", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_AABBS_KHR, if geometry.aabbs.data.deviceAddress is the address of a non-sparse buffer then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03714", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_AABBS_KHR, geometry.aabbs.data.deviceAddress must be aligned to 8 bytes" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03715", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR, if geometry.arrayOfPointers is VK_FALSE, geometry.instances.data.deviceAddress must be aligned to 16 bytes" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03716", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR, if geometry.arrayOfPointers is VK_TRUE, geometry.instances.data.deviceAddress must be aligned to 8 bytes" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03717", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR, if geometry.arrayOfPointers is VK_TRUE, each element of geometry.instances.data.deviceAddress in device memory must be aligned to 16 bytes" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03813", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR, geometry.instances.data.deviceAddress must be a valid device address obtained from vkGetBufferDeviceAddress" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03814", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR, if geometry.instances.data.deviceAddress is the address of a non-sparse buffer then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03815", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR, each VkAccelerationStructureInstanceKHR::accelerationStructureReference value in geometry.instances.data.deviceAddress must be a valid device address containing a value obtained from vkGetAccelerationStructureDeviceAddressKHR" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-pInfos-03675", + "text": " For each pInfos[i], dstAccelerationStructure must have been created with a value of VkAccelerationStructureCreateInfoKHR::size greater than or equal to the memory size required by the build operation, as returned by vkGetAccelerationStructureBuildSizesKHR with pBuildInfo = pInfos[i] and with each element of the pMaxPrimitiveCounts array greater than or equal to the equivalent ppBuildRangeInfos[i][j].primitiveCount values for j in [0,pInfos[i].geometryCount)" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresKHR-ppBuildRangeInfos-03676", + "text": " Each element of ppBuildRangeInfos[i] must be a valid pointer to an array of pInfos[i].geometryCount VkAccelerationStructureBuildRangeInfoKHR structures" + } + ] + }, + "vkCmdBuildAccelerationStructuresIndirectKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-mode-04628", + "text": " The mode member of each element of pInfos must be a valid VkBuildAccelerationStructureModeKHR value" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-srcAccelerationStructure-04629", + "text": " If the srcAccelerationStructure member of any element of pInfos is not VK_NULL_HANDLE, the srcAccelerationStructure member must be a valid VkAccelerationStructureKHR handle" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-04630", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, its srcAccelerationStructure member must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03403", + "text": " The srcAccelerationStructure member of any element of pInfos must not be the same acceleration structure as the dstAccelerationStructure member of any other element of pInfos" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-dstAccelerationStructure-03698", + "text": " The dstAccelerationStructure member of any element of pInfos must not be the same acceleration structure as the dstAccelerationStructure member of any other element of pInfos" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-dstAccelerationStructure-03800", + "text": " The dstAccelerationStructure member of any element of pInfos must be a valid VkAccelerationStructureKHR handle" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03699", + "text": " For each element of pInfos, if its type member is VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, its dstAccelerationStructure member must have been created with a value of VkAccelerationStructureCreateInfoKHR::type equal to either VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR or VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03700", + "text": " For each element of pInfos, if its type member is VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR, its dstAccelerationStructure member must have been created with a value of VkAccelerationStructureCreateInfoKHR::type equal to either VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR or VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03663", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, inactive primitives in its srcAccelerationStructure member must not be made active" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03664", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, active primitives in its srcAccelerationStructure member must not be made inactive" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-None-03407", + "text": " The dstAccelerationStructure member of any element of pInfos must not be referenced by the geometry.instances.data member of any element of pGeometries or ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR in any other element of pInfos" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-dstAccelerationStructure-03701", + "text": " The range of memory backing the dstAccelerationStructure member of any element of pInfos that is accessed by this command must not overlap the memory backing the srcAccelerationStructure member of any other element of pInfos with a mode equal to VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, which is accessed by this command" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-dstAccelerationStructure-03702", + "text": " The range of memory backing the dstAccelerationStructure member of any element of pInfos that is accessed by this command must not overlap the memory backing the dstAccelerationStructure member of any other element of pInfos, which is accessed by this command" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-dstAccelerationStructure-03703", + "text": " The range of memory backing the dstAccelerationStructure member of any element of pInfos that is accessed by this command must not overlap the memory backing the scratchData member of any element of pInfos (including the same element), which is accessed by this command" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-scratchData-03704", + "text": " The range of memory backing the scratchData member of any element of pInfos that is accessed by this command must not overlap the memory backing the scratchData member of any other element of pInfos, which is accessed by this command" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-scratchData-03705", + "text": " The range of memory backing the scratchData member of any element of pInfos that is accessed by this command must not overlap the memory backing the srcAccelerationStructure member of any element of pInfos with a mode equal to VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR (including the same element), which is accessed by this command" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-dstAccelerationStructure-03706", + "text": " The range of memory backing the dstAccelerationStructure member of any element of pInfos that is accessed by this command must not overlap the memory backing any acceleration structure referenced by the geometry.instances.data member of any element of pGeometries or ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR in any other element of pInfos, which is accessed by this command" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03667", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, its srcAccelerationStructure member must have previously been constructed with VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR set in VkAccelerationStructureBuildGeometryInfoKHR::flags in the build" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03668", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, its srcAccelerationStructure and dstAccelerationStructure members must either be the same VkAccelerationStructureKHR, or not have any memory aliasing" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03758", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, its geometryCount member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03759", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, its flags member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03760", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, its type member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03761", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, its geometryType member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03762", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, its flags member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03763", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, if geometryType is VK_GEOMETRY_TYPE_TRIANGLES_KHR, its geometry.triangles.vertexFormat member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03764", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, if geometryType is VK_GEOMETRY_TYPE_TRIANGLES_KHR, its geometry.triangles.maxVertex member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03765", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, if geometryType is VK_GEOMETRY_TYPE_TRIANGLES_KHR, its geometry.triangles.indexType member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03766", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, if geometryType is VK_GEOMETRY_TYPE_TRIANGLES_KHR, if its geometry.triangles.transformData address was NULL when srcAccelerationStructure was last built, then it must be NULL" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03767", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, if geometryType is VK_GEOMETRY_TYPE_TRIANGLES_KHR, if its geometry.triangles.transformData address was not NULL when srcAccelerationStructure was last built, then it must not be NULL" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03768", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, if geometryType is VK_GEOMETRY_TYPE_TRIANGLES_KHR, and geometry.triangles.indexType is not VK_INDEX_TYPE_NONE_KHR, then the value of each index referenced must be the same as the corresponding index value when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-primitiveCount-03769", + "text": " For each VkAccelerationStructureBuildRangeInfoKHR referenced by this command, its primitiveCount member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-firstVertex-03770", + "text": " For each VkAccelerationStructureBuildRangeInfoKHR referenced by this command, if the corresponding geometry uses indices, its firstVertex member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03801", + "text": " For each element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR, the corresponding {maxinstancecheck} must be less than or equal to VkPhysicalDeviceAccelerationStructurePropertiesKHR::maxInstanceCount" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03707", + "text": " For each element of pInfos, the buffer used to create its dstAccelerationStructure member must be bound to device memory" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03708", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR the buffer used to create its srcAccelerationStructure member must be bound to device memory" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03709", + "text": " For each element of pInfos, the buffer used to create each acceleration structure referenced by the geometry.instances.data member of any element of pGeometries or ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR must be bound to device memory" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03671", + "text": " If pInfos[i].mode is VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR, all addresses between pInfos[i].scratchData.deviceAddress and pInfos[i].scratchData.deviceAddress + N - 1 must be in the buffer device address range of the same buffer, where N is given by the buildScratchSize member of the VkAccelerationStructureBuildSizesInfoKHR structure returned from a call to vkGetAccelerationStructureBuildSizesKHR with an identical VkAccelerationStructureBuildGeometryInfoKHR structure and primitive count" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03672", + "text": " If pInfos[i].mode is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, all addresses between pInfos[i].scratchData.deviceAddress and pInfos[i].scratchData.deviceAddress + N - 1 must be in the buffer device address range of the same buffer, where N is given by the updateScratchSize member of the VkAccelerationStructureBuildSizesInfoKHR structure returned from a call to vkGetAccelerationStructureBuildSizesKHR with an identical VkAccelerationStructureBuildGeometryInfoKHR structure and primitive count" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-geometry-03673", + "text": " The buffers from which the buffer device addresses for all of the geometry.triangles.vertexData, geometry.triangles.indexData, geometry.triangles.transformData, geometry.aabbs.data, and geometry.instances.data members of all pInfos[i].pGeometries and pInfos[i].ppGeometries are queried must have been created with the VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR usage flag" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03674", + "text": " The buffer from which the buffer device address pInfos[i].scratchData.deviceAddress is queried must have been created with VK_BUFFER_USAGE_STORAGE_BUFFER_BIT usage flag" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03802", + "text": " For each element of pInfos, its scratchData.deviceAddress member must be a valid device address obtained from vkGetBufferDeviceAddress" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03803", + "text": " For each element of pInfos, if scratchData.deviceAddress is the address of a non-sparse buffer then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03710", + "text": " For each element of pInfos, its scratchData.deviceAddress member must be a multiple of VkPhysicalDeviceAccelerationStructurePropertiesKHR::minAccelerationStructureScratchOffsetAlignment" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03804", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, geometry.triangles.vertexData.deviceAddress must be a valid device address obtained from vkGetBufferDeviceAddress" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03805", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, if geometry.triangles.vertexData.deviceAddress is the address of a non-sparse buffer then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03711", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, geometry.triangles.vertexData.deviceAddress must be aligned to the size in bytes of the smallest component of the format in vertexFormat" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03806", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, if geometry.triangles.indexType is not VK_INDEX_TYPE_NONE_KHR, geometry.triangles.indexData.deviceAddress must be a valid device address obtained from vkGetBufferDeviceAddress" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03807", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, if geometry.triangles.indexType is not VK_INDEX_TYPE_NONE_KHR, if geometry.triangles.indexData.deviceAddress is the address of a non-sparse buffer then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03712", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, and with geometry.triangles.indexType not equal to VK_INDEX_TYPE_NONE_KHR, geometry.triangles.indexData.deviceAddress must be aligned to the size in bytes of the type in indexType" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03808", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, if geometry.triangles.transformData.deviceAddress is not 0, it must be a valid device address obtained from vkGetBufferDeviceAddress" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03809", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, if geometry.triangles.transformData.deviceAddress is the address of a non-sparse buffer then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03810", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, if geometry.triangles.transformData.deviceAddress is not 0, it must be aligned to 16 bytes" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03811", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_AABBS_KHR, geometry.aabbs.data.deviceAddress must be a valid device address obtained from vkGetBufferDeviceAddress" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03812", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_AABBS_KHR, if geometry.aabbs.data.deviceAddress is the address of a non-sparse buffer then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03714", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_AABBS_KHR, geometry.aabbs.data.deviceAddress must be aligned to 8 bytes" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03715", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR, if geometry.arrayOfPointers is VK_FALSE, geometry.instances.data.deviceAddress must be aligned to 16 bytes" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03716", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR, if geometry.arrayOfPointers is VK_TRUE, geometry.instances.data.deviceAddress must be aligned to 8 bytes" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03717", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR, if geometry.arrayOfPointers is VK_TRUE, each element of geometry.instances.data.deviceAddress in device memory must be aligned to 16 bytes" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03813", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR, geometry.instances.data.deviceAddress must be a valid device address obtained from vkGetBufferDeviceAddress" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03814", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR, if geometry.instances.data.deviceAddress is the address of a non-sparse buffer then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03815", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR, each VkAccelerationStructureInstanceKHR::accelerationStructureReference value in geometry.instances.data.deviceAddress must be a valid device address containing a value obtained from vkGetAccelerationStructureDeviceAddressKHR" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pIndirectDeviceAddresses-03645", + "text": " For any element of pIndirectDeviceAddresses, if the buffer from which it was queried is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pIndirectDeviceAddresses-03646", + "text": " For any element of pIndirectDeviceAddresses[i], all device addresses between pIndirectDeviceAddresses[i] and pIndirectDeviceAddresses[i] + (pInfos[i].geometryCount {times} pIndirectStrides[i]) - 1 must be in the buffer device address range of the same buffer" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pIndirectDeviceAddresses-03647", + "text": " For any element of pIndirectDeviceAddresses, the buffer from which it was queried must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pIndirectDeviceAddresses-03648", + "text": " Each element of pIndirectDeviceAddresses must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pIndirectStrides-03787", + "text": " Each element of pIndirectStrides must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-commandBuffer-03649", + "text": " commandBuffer must not be a protected command buffer" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-accelerationStructureIndirectBuild-03650", + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureIndirectBuild feature must be enabled" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pIndirectDeviceAddresses-03651", + "text": " Each VkAccelerationStructureBuildRangeInfoKHR structure referenced by any element of pIndirectDeviceAddresses must be a valid VkAccelerationStructureBuildRangeInfoKHR structure" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-pInfos-03652", + "text": " pInfos[i].dstAccelerationStructure must have been created with a value of VkAccelerationStructureCreateInfoKHR::size greater than or equal to the memory size required by the build operation, as returned by vkGetAccelerationStructureBuildSizesKHR with pBuildInfo = pInfos[i] and pMaxPrimitiveCounts = ppMaxPrimitiveCounts[i]" + }, + { + "vuid": "VUID-vkCmdBuildAccelerationStructuresIndirectKHR-ppMaxPrimitiveCounts-03653", + "text": " Each ppMaxPrimitiveCounts[i][j] must be greater than or equal to the the primitiveCount value specified by the VkAccelerationStructureBuildRangeInfoKHR structure located at pIndirectDeviceAddresses[i] + (j {times} pIndirectStrides[i])" + } + ] + }, + "VkAccelerationStructureBuildGeometryInfoKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-VkAccelerationStructureBuildGeometryInfoKHR-type-03654", + "text": " type must not be VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR" + }, + { + "vuid": "VUID-VkAccelerationStructureBuildGeometryInfoKHR-pGeometries-03788", + "text": " Only one of pGeometries or ppGeometries can be a valid pointer, the other must be NULL" + }, + { + "vuid": "VUID-VkAccelerationStructureBuildGeometryInfoKHR-type-03789", + "text": " If type is VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, the geometryType member of elements of either pGeometries or ppGeometries must be VK_GEOMETRY_TYPE_INSTANCES_KHR" + }, + { + "vuid": "VUID-VkAccelerationStructureBuildGeometryInfoKHR-type-03790", + "text": " If type is VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, geometryCount must be 1" + }, + { + "vuid": "VUID-VkAccelerationStructureBuildGeometryInfoKHR-type-03791", + "text": " If type is VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR the geometryType member of elements of either pGeometries or ppGeometries must not be VK_GEOMETRY_TYPE_INSTANCES_KHR" + }, + { + "vuid": "VUID-VkAccelerationStructureBuildGeometryInfoKHR-type-03792", + "text": " If type is VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR then the geometryType member of each geometry in either pGeometries or ppGeometries must be the same" + }, + { + "vuid": "VUID-VkAccelerationStructureBuildGeometryInfoKHR-type-03793", + "text": " If type is VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR then geometryCount must be less than or equal to VkPhysicalDeviceAccelerationStructurePropertiesKHR::maxGeometryCount" + }, + { + "vuid": "VUID-VkAccelerationStructureBuildGeometryInfoKHR-type-03794", + "text": " If type is VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR and the geometryType member of either pGeometries or ppGeometries is VK_GEOMETRY_TYPE_AABBS_KHR, the total number of AABBs in all geometries must be less than or equal to VkPhysicalDeviceAccelerationStructurePropertiesKHR::maxPrimitiveCount" + }, + { + "vuid": "VUID-VkAccelerationStructureBuildGeometryInfoKHR-type-03795", + "text": " If type is VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR and the geometryType member of either pGeometries or ppGeometries is VK_GEOMETRY_TYPE_TRIANGLES_KHR, the total number of triangles in all geometries must be less than or equal to VkPhysicalDeviceAccelerationStructurePropertiesKHR::maxPrimitiveCount" + }, + { + "vuid": "VUID-VkAccelerationStructureBuildGeometryInfoKHR-flags-03796", + "text": " If flags has the VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR bit set, then it must not have the VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR bit set" + } + ], + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)+(VK_NV_ray_tracing_motion_blur)": [ + { + "vuid": "VUID-VkAccelerationStructureBuildGeometryInfoKHR-dstAccelerationStructure-04927", + "text": " If dstAccelerationStructure was created with VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV set in VkAccelerationStructureCreateInfoKHR::flags, VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV must be set in flags" + }, + { + "vuid": "VUID-VkAccelerationStructureBuildGeometryInfoKHR-flags-04928", + "text": " If VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV is set in flags, dstAccelerationStructure must have been created with VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV set in VkAccelerationStructureCreateInfoKHR::flags" + }, + { + "vuid": "VUID-VkAccelerationStructureBuildGeometryInfoKHR-flags-04929", + "text": " If VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV is set in flags, type must not be VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR" + } + ] + }, + "VkAccelerationStructureGeometryTrianglesDataKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-VkAccelerationStructureGeometryTrianglesDataKHR-vertexStride-03735", + "text": " vertexStride must be a multiple of the size in bytes of the smallest component of vertexFormat" + }, + { + "vuid": "VUID-VkAccelerationStructureGeometryTrianglesDataKHR-vertexStride-03819", + "text": " vertexStride must be less than or equal to 232-1" + }, + { + "vuid": "VUID-VkAccelerationStructureGeometryTrianglesDataKHR-vertexFormat-03797", + "text": " vertexFormat must support the VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR in VkFormatProperties::bufferFeatures as returned by vkGetPhysicalDeviceFormatProperties2" + }, + { + "vuid": "VUID-VkAccelerationStructureGeometryTrianglesDataKHR-indexType-03798", + "text": " indexType must be VK_INDEX_TYPE_UINT16, VK_INDEX_TYPE_UINT32, or VK_INDEX_TYPE_NONE_KHR" + } + ] + }, + "VkTransformMatrixKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-VkTransformMatrixKHR-matrix-03799", + "text": " The first three columns of matrix must define an invertible 3x3 matrix" + } + ] + }, + "VkAccelerationStructureGeometryAabbsDataKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-VkAccelerationStructureGeometryAabbsDataKHR-stride-03545", + "text": " stride must be a multiple of 8" + }, + { + "vuid": "VUID-VkAccelerationStructureGeometryAabbsDataKHR-stride-03820", + "text": " stride must be less than or equal to 232-1" + } + ] + }, + "VkAabbPositionsKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-VkAabbPositionsKHR-minX-03546", + "text": " minX must be less than or equal to maxX" + }, + { + "vuid": "VUID-VkAabbPositionsKHR-minY-03547", + "text": " minY must be less than or equal to maxY" + }, + { + "vuid": "VUID-VkAabbPositionsKHR-minZ-03548", + "text": " minZ must be less than or equal to maxZ" + } + ] + }, + "VkAccelerationStructureBuildRangeInfoKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-VkAccelerationStructureBuildRangeInfoKHR-primitiveOffset-03656", + "text": " For geometries of type VK_GEOMETRY_TYPE_TRIANGLES_KHR, if the geometry uses indices, the offset primitiveOffset from VkAccelerationStructureGeometryTrianglesDataKHR::indexData must be a multiple of the element size of VkAccelerationStructureGeometryTrianglesDataKHR::indexType" + }, + { + "vuid": "VUID-VkAccelerationStructureBuildRangeInfoKHR-primitiveOffset-03657", + "text": " For geometries of type VK_GEOMETRY_TYPE_TRIANGLES_KHR, if the geometry does not use indices, the offset primitiveOffset from VkAccelerationStructureGeometryTrianglesDataKHR::vertexData must be a multiple of the component size of VkAccelerationStructureGeometryTrianglesDataKHR::vertexFormat" + }, + { + "vuid": "VUID-VkAccelerationStructureBuildRangeInfoKHR-transformOffset-03658", + "text": " For geometries of type VK_GEOMETRY_TYPE_TRIANGLES_KHR, the offset transformOffset from VkAccelerationStructureGeometryTrianglesDataKHR::transformData must be a multiple of 16" + }, + { + "vuid": "VUID-VkAccelerationStructureBuildRangeInfoKHR-primitiveOffset-03659", + "text": " For geometries of type VK_GEOMETRY_TYPE_AABBS_KHR, the offset primitiveOffset from VkAccelerationStructureGeometryAabbsDataKHR::data must be a multiple of 8" + }, + { + "vuid": "VUID-VkAccelerationStructureBuildRangeInfoKHR-primitiveOffset-03660", + "text": " For geometries of type VK_GEOMETRY_TYPE_INSTANCES_KHR, the offset primitiveOffset from VkAccelerationStructureGeometryInstancesDataKHR::data must be a multiple of 16" + } + ] + }, + "vkCmdWriteAccelerationStructuresPropertiesKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-queryPool-02493", + "text": " queryPool must have been created with a queryType matching queryType" + }, + { + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-queryPool-02494", + "text": " The queries identified by queryPool and firstQuery must be unavailable" + }, + { + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-buffer-03736", + "text": " The buffer used to create each acceleration structure in pAccelerationStructures must be bound to device memory" + }, + { + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-query-04880", + "text": " The sum of query plus accelerationStructureCount must be less than or equal to the number of queries in queryPool" + }, + { + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-pAccelerationStructures-04964", + "text": " All acceleration structures in pAccelerationStructures must have been built prior to the execution of this command" + }, + { + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-accelerationStructures-03431", + "text": " All acceleration structures in pAccelerationStructures must have been built with VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR if queryType is VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR" + }, + { + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-queryType-03432", + "text": " queryType must be VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR or VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR" + } + ] + }, + "vkCmdWriteAccelerationStructuresPropertiesNV": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryPool-03755", + "text": " queryPool must have been created with a queryType matching queryType" + }, + { + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryPool-03756", + "text": " The queries identified by queryPool and firstQuery must be unavailable" + }, + { + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-accelerationStructure-03757", + "text": " accelerationStructure must be bound completely and contiguously to a single VkDeviceMemory object via vkBindAccelerationStructureMemoryNV" + }, + { + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-pAccelerationStructures-04958", + "text": " All acceleration structures in pAccelerationStructures must have been built prior to the execution of this command" + }, + { + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-pAccelerationStructures-06215", + "text": " All acceleration structures in pAccelerationStructures must have been built with VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR if queryType is VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV" + }, + { + "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryType-06216", + "text": " queryType must be VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV" + } + ] + }, + "vkCmdCopyAccelerationStructureNV": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-vkCmdCopyAccelerationStructureNV-mode-03410", + "text": " mode must be VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR or VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR" + }, + { + "vuid": "VUID-vkCmdCopyAccelerationStructureNV-src-04963", + "text": " The source acceleration structure src must have been constructed prior to the execution of this command" + }, + { + "vuid": "VUID-vkCmdCopyAccelerationStructureNV-src-03411", + "text": " If mode is VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR, src must have been constructed with VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR in the build" + }, + { + "vuid": "VUID-vkCmdCopyAccelerationStructureNV-buffer-03718", + "text": " The buffer used to create src must be bound to device memory" + }, + { + "vuid": "VUID-vkCmdCopyAccelerationStructureNV-buffer-03719", + "text": " The buffer used to create dst must be bound to device memory" + } + ] + }, + "vkCmdCopyAccelerationStructureKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCmdCopyAccelerationStructureKHR-buffer-03737", + "text": " The buffer used to create pInfo->src must be bound to device memory" + }, + { + "vuid": "VUID-vkCmdCopyAccelerationStructureKHR-buffer-03738", + "text": " The buffer used to create pInfo->dst must be bound to device memory" + } + ] + }, + "VkCopyAccelerationStructureInfoKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-VkCopyAccelerationStructureInfoKHR-mode-03410", + "text": " mode must be VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR or VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR" + }, + { + "vuid": "VUID-VkCopyAccelerationStructureInfoKHR-src-04963", + "text": " The source acceleration structure src must have been constructed prior to the execution of this command" + }, + { + "vuid": "VUID-VkCopyAccelerationStructureInfoKHR-src-03411", + "text": " If mode is VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR, src must have been constructed with VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR in the build" + }, + { + "vuid": "VUID-VkCopyAccelerationStructureInfoKHR-buffer-03718", + "text": " The buffer used to create src must be bound to device memory" + }, + { + "vuid": "VUID-VkCopyAccelerationStructureInfoKHR-buffer-03719", + "text": " The buffer used to create dst must be bound to device memory" + } + ] + }, + "vkCmdCopyAccelerationStructureToMemoryKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCmdCopyAccelerationStructureToMemoryKHR-pInfo-03739", + "text": " pInfo->dst.deviceAddress must be a valid device address for a buffer bound to device memory" + }, + { + "vuid": "VUID-vkCmdCopyAccelerationStructureToMemoryKHR-pInfo-03740", + "text": " pInfo->dst.deviceAddress must be aligned to 256 bytes" + }, + { + "vuid": "VUID-vkCmdCopyAccelerationStructureToMemoryKHR-pInfo-03741", + "text": " If the buffer pointed to by pInfo->dst.deviceAddress is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyAccelerationStructureToMemoryKHR-None-03559", + "text": " The buffer used to create pInfo->src must be bound to device memory" + } + ] + }, + "VkCopyAccelerationStructureToMemoryInfoKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-VkCopyAccelerationStructureToMemoryInfoKHR-src-04959", + "text": " The source acceleration structure src must have been constructed prior to the execution of this command" + }, + { + "vuid": "VUID-VkCopyAccelerationStructureToMemoryInfoKHR-dst-03561", + "text": " The memory pointed to by dst must be at least as large as the serialization size of src, as reported by vkWriteAccelerationStructuresPropertiesKHR or vkCmdWriteAccelerationStructuresPropertiesKHR with a query type of VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR" + }, + { + "vuid": "VUID-VkCopyAccelerationStructureToMemoryInfoKHR-mode-03412", + "text": " mode must be VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR" + } + ] + }, + "vkCmdCopyMemoryToAccelerationStructureKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCmdCopyMemoryToAccelerationStructureKHR-pInfo-03742", + "text": " pInfo->src.deviceAddress must be a valid device address for a buffer bound to device memory" + }, + { + "vuid": "VUID-vkCmdCopyMemoryToAccelerationStructureKHR-pInfo-03743", + "text": " pInfo->src.deviceAddress must be aligned to 256 bytes" + }, + { + "vuid": "VUID-vkCmdCopyMemoryToAccelerationStructureKHR-pInfo-03744", + "text": " If the buffer pointed to by pInfo->src.deviceAddress is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdCopyMemoryToAccelerationStructureKHR-buffer-03745", + "text": " The buffer used to create pInfo->dst must be bound to device memory" + } + ] + }, + "VkCopyMemoryToAccelerationStructureInfoKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-VkCopyMemoryToAccelerationStructureInfoKHR-src-04960", + "text": " The source memory pointed to by src must contain data previously serialized using vkCmdCopyAccelerationStructureToMemoryKHR, potentially modified to relocate acceleration structure references as described in that command" + }, + { + "vuid": "VUID-VkCopyMemoryToAccelerationStructureInfoKHR-mode-03413", + "text": " mode must be VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR" + }, + { + "vuid": "VUID-VkCopyMemoryToAccelerationStructureInfoKHR-pInfo-03414", + "text": " The data in src must have a format compatible with the destination physical device as returned by vkGetDeviceAccelerationStructureCompatibilityKHR" + }, + { + "vuid": "VUID-VkCopyMemoryToAccelerationStructureInfoKHR-dst-03746", + "text": " dst must have been created with a size greater than or equal to that used to serialize the data in src" + } + ] + }, + "vkGetDeviceAccelerationStructureCompatibilityKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkGetDeviceAccelerationStructureCompatibilityKHR-rayTracingPipeline-03661", + "text": " The rayTracingPipeline or rayQuery feature must be enabled" + } + ] + }, + "vkBuildAccelerationStructuresKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-mode-04628", + "text": " The mode member of each element of pInfos must be a valid VkBuildAccelerationStructureModeKHR value" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-srcAccelerationStructure-04629", + "text": " If the srcAccelerationStructure member of any element of pInfos is not VK_NULL_HANDLE, the srcAccelerationStructure member must be a valid VkAccelerationStructureKHR handle" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-04630", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, its srcAccelerationStructure member must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03403", + "text": " The srcAccelerationStructure member of any element of pInfos must not be the same acceleration structure as the dstAccelerationStructure member of any other element of pInfos" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-dstAccelerationStructure-03698", + "text": " The dstAccelerationStructure member of any element of pInfos must not be the same acceleration structure as the dstAccelerationStructure member of any other element of pInfos" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-dstAccelerationStructure-03800", + "text": " The dstAccelerationStructure member of any element of pInfos must be a valid VkAccelerationStructureKHR handle" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03699", + "text": " For each element of pInfos, if its type member is VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, its dstAccelerationStructure member must have been created with a value of VkAccelerationStructureCreateInfoKHR::type equal to either VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR or VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03700", + "text": " For each element of pInfos, if its type member is VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR, its dstAccelerationStructure member must have been created with a value of VkAccelerationStructureCreateInfoKHR::type equal to either VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR or VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03663", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, inactive primitives in its srcAccelerationStructure member must not be made active" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03664", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, active primitives in its srcAccelerationStructure member must not be made inactive" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-None-03407", + "text": " The dstAccelerationStructure member of any element of pInfos must not be referenced by the geometry.instances.data member of any element of pGeometries or ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR in any other element of pInfos" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-dstAccelerationStructure-03701", + "text": " The range of memory backing the dstAccelerationStructure member of any element of pInfos that is accessed by this command must not overlap the memory backing the srcAccelerationStructure member of any other element of pInfos with a mode equal to VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, which is accessed by this command" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-dstAccelerationStructure-03702", + "text": " The range of memory backing the dstAccelerationStructure member of any element of pInfos that is accessed by this command must not overlap the memory backing the dstAccelerationStructure member of any other element of pInfos, which is accessed by this command" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-dstAccelerationStructure-03703", + "text": " The range of memory backing the dstAccelerationStructure member of any element of pInfos that is accessed by this command must not overlap the memory backing the scratchData member of any element of pInfos (including the same element), which is accessed by this command" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-scratchData-03704", + "text": " The range of memory backing the scratchData member of any element of pInfos that is accessed by this command must not overlap the memory backing the scratchData member of any other element of pInfos, which is accessed by this command" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-scratchData-03705", + "text": " The range of memory backing the scratchData member of any element of pInfos that is accessed by this command must not overlap the memory backing the srcAccelerationStructure member of any element of pInfos with a mode equal to VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR (including the same element), which is accessed by this command" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-dstAccelerationStructure-03706", + "text": " The range of memory backing the dstAccelerationStructure member of any element of pInfos that is accessed by this command must not overlap the memory backing any acceleration structure referenced by the geometry.instances.data member of any element of pGeometries or ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR in any other element of pInfos, which is accessed by this command" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03667", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, its srcAccelerationStructure member must have previously been constructed with VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR set in VkAccelerationStructureBuildGeometryInfoKHR::flags in the build" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03668", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, its srcAccelerationStructure and dstAccelerationStructure members must either be the same VkAccelerationStructureKHR, or not have any memory aliasing" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03758", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, its geometryCount member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03759", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, its flags member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03760", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, its type member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03761", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, its geometryType member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03762", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, its flags member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03763", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, if geometryType is VK_GEOMETRY_TYPE_TRIANGLES_KHR, its geometry.triangles.vertexFormat member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03764", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, if geometryType is VK_GEOMETRY_TYPE_TRIANGLES_KHR, its geometry.triangles.maxVertex member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03765", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, if geometryType is VK_GEOMETRY_TYPE_TRIANGLES_KHR, its geometry.triangles.indexType member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03766", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, if geometryType is VK_GEOMETRY_TYPE_TRIANGLES_KHR, if its geometry.triangles.transformData address was NULL when srcAccelerationStructure was last built, then it must be NULL" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03767", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, if geometryType is VK_GEOMETRY_TYPE_TRIANGLES_KHR, if its geometry.triangles.transformData address was not NULL when srcAccelerationStructure was last built, then it must not be NULL" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03768", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, then for each VkAccelerationStructureGeometryKHR structure referred to by its pGeometries or ppGeometries members, if geometryType is VK_GEOMETRY_TYPE_TRIANGLES_KHR, and geometry.triangles.indexType is not VK_INDEX_TYPE_NONE_KHR, then the value of each index referenced must be the same as the corresponding index value when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-primitiveCount-03769", + "text": " For each VkAccelerationStructureBuildRangeInfoKHR referenced by this command, its primitiveCount member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-firstVertex-03770", + "text": " For each VkAccelerationStructureBuildRangeInfoKHR referenced by this command, if the corresponding geometry uses indices, its firstVertex member must have the same value which was specified when srcAccelerationStructure was last built" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03801", + "text": " For each element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR, the corresponding {maxinstancecheck} must be less than or equal to VkPhysicalDeviceAccelerationStructurePropertiesKHR::maxInstanceCount" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03675", + "text": " For each pInfos[i], dstAccelerationStructure must have been created with a value of VkAccelerationStructureCreateInfoKHR::size greater than or equal to the memory size required by the build operation, as returned by vkGetAccelerationStructureBuildSizesKHR with pBuildInfo = pInfos[i] and with each element of the pMaxPrimitiveCounts array greater than or equal to the equivalent ppBuildRangeInfos[i][j].primitiveCount values for j in [0,pInfos[i].geometryCount)" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-ppBuildRangeInfos-03676", + "text": " Each element of ppBuildRangeInfos[i] must be a valid pointer to an array of pInfos[i].geometryCount VkAccelerationStructureBuildRangeInfoKHR structures" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-deferredOperation-03677", + "text": " If deferredOperation is not VK_NULL_HANDLE, it must be a valid VkDeferredOperationKHR object" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-deferredOperation-03678", + "text": " Any previous deferred operation that was associated with deferredOperation must be complete" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03722", + "text": " For each element of pInfos, the buffer used to create its dstAccelerationStructure member must be bound to host-visible device memory" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03723", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR the buffer used to create its srcAccelerationStructure member must be bound to host-visible device memory" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03724", + "text": " For each element of pInfos, the buffer used to create each acceleration structure referenced by the geometry.instances.data member of any element of pGeometries or ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR must be bound to host-visible device memory" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-accelerationStructureHostCommands-03581", + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureHostCommands feature must be enabled" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03725", + "text": " If pInfos[i].mode is VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR, all addresses between pInfos[i].scratchData.hostAddress and pInfos[i].scratchData.hostAddress + N - 1 must be valid host memory, where N is given by the buildScratchSize member of the VkAccelerationStructureBuildSizesInfoKHR structure returned from a call to vkGetAccelerationStructureBuildSizesKHR with an identical VkAccelerationStructureBuildGeometryInfoKHR structure and primitive count" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03726", + "text": " If pInfos[i].mode is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR, all addresses between pInfos[i].scratchData.hostAddress and pInfos[i].scratchData.hostAddress + N - 1 must be valid host memory, where N is given by the updateScratchSize member of the VkAccelerationStructureBuildSizesInfoKHR structure returned from a call to vkGetAccelerationStructureBuildSizesKHR with an identical VkAccelerationStructureBuildGeometryInfoKHR structure and primitive count" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03771", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, geometry.triangles.vertexData.hostAddress must be a valid host address" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03772", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, if geometry.triangles.indexType is not VK_INDEX_TYPE_NONE_KHR, geometry.triangles.indexData.hostAddress must be a valid host address" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03773", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR, if geometry.triangles.transformData.hostAddress is not 0, it must be a valid host address" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03774", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_AABBS_KHR, geometry.aabbs.data.hostAddress must be a valid host address" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03778", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR, geometry.instances.data.hostAddress must be a valid host address" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03779", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR, each VkAccelerationStructureInstanceKHR::accelerationStructureReference value in geometry.instances.data.hostAddress must be a valid VkAccelerationStructureKHR object" + } + ], + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_device_group,VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03775", + "text": " For each element of pInfos, the buffer used to create its dstAccelerationStructure member must be bound to memory that was not allocated with multiple instances" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03776", + "text": " For each element of pInfos, if its mode member is VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR the buffer used to create its srcAccelerationStructure member must be bound to memory that was not allocated with multiple instances" + }, + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-03777", + "text": " For each element of pInfos, the buffer used to create each acceleration structure referenced by the geometry.instances.data member of any element of pGeometries or ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR must be bound to memory that was not allocated with multiple instances" + } + ], + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_NV_ray_tracing_motion_blur)": [ + { + "vuid": "VUID-vkBuildAccelerationStructuresKHR-pInfos-04930", + "text": " For any element of pInfos[i].pGeometries or pInfos[i].ppGeometries with a geometryType of VK_GEOMETRY_TYPE_INSTANCES_KHR with VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV set, each accelerationStructureReference in any structure in VkAccelerationStructureMotionInstanceNV value in geometry.instances.data.hostAddress must be a valid VkAccelerationStructureKHR object" + } + ] + }, + "vkCopyAccelerationStructureKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCopyAccelerationStructureKHR-deferredOperation-03677", + "text": " If deferredOperation is not VK_NULL_HANDLE, it must be a valid VkDeferredOperationKHR object" + }, + { + "vuid": "VUID-vkCopyAccelerationStructureKHR-deferredOperation-03678", + "text": " Any previous deferred operation that was associated with deferredOperation must be complete" + }, + { + "vuid": "VUID-vkCopyAccelerationStructureKHR-buffer-03727", + "text": " The buffer used to create pInfo->src must be bound to host-visible device memory" + }, + { + "vuid": "VUID-vkCopyAccelerationStructureKHR-buffer-03728", + "text": " The buffer used to create pInfo->dst must be bound to host-visible device memory" + }, + { + "vuid": "VUID-vkCopyAccelerationStructureKHR-accelerationStructureHostCommands-03582", + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureHostCommands feature must be enabled" + } + ], + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_device_group,VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCopyAccelerationStructureKHR-buffer-03780", + "text": " The buffer used to create pInfo->src must be bound to memory that was not allocated with multiple instances" + }, + { + "vuid": "VUID-vkCopyAccelerationStructureKHR-buffer-03781", + "text": " The buffer used to create pInfo->dst must be bound to memory that was not allocated with multiple instances" + } + ] + }, + "vkCopyMemoryToAccelerationStructureKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCopyMemoryToAccelerationStructureKHR-deferredOperation-03677", + "text": " If deferredOperation is not VK_NULL_HANDLE, it must be a valid VkDeferredOperationKHR object" + }, + { + "vuid": "VUID-vkCopyMemoryToAccelerationStructureKHR-deferredOperation-03678", + "text": " Any previous deferred operation that was associated with deferredOperation must be complete" + }, + { + "vuid": "VUID-vkCopyMemoryToAccelerationStructureKHR-pInfo-03729", + "text": " pInfo->src.hostAddress must be a valid host pointer" + }, + { + "vuid": "VUID-vkCopyMemoryToAccelerationStructureKHR-pInfo-03750", + "text": " pInfo->src.hostAddress must be aligned to 16 bytes" + }, + { + "vuid": "VUID-vkCopyMemoryToAccelerationStructureKHR-buffer-03730", + "text": " The buffer used to create pInfo->dst must be bound to host-visible device memory" + }, + { + "vuid": "VUID-vkCopyMemoryToAccelerationStructureKHR-accelerationStructureHostCommands-03583", + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureHostCommands feature must be enabled" + } + ], + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_device_group,VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCopyMemoryToAccelerationStructureKHR-buffer-03782", + "text": " The buffer used to create pInfo->dst must be bound to memory that was not allocated with multiple instances" + } + ] + }, + "vkCopyAccelerationStructureToMemoryKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkCopyAccelerationStructureToMemoryKHR-deferredOperation-03677", + "text": " If deferredOperation is not VK_NULL_HANDLE, it must be a valid VkDeferredOperationKHR object" + }, + { + "vuid": "VUID-vkCopyAccelerationStructureToMemoryKHR-deferredOperation-03678", + "text": " Any previous deferred operation that was associated with deferredOperation must be complete" + }, + { + "vuid": "VUID-vkCopyAccelerationStructureToMemoryKHR-buffer-03731", + "text": " The buffer used to create pInfo->src must be bound to host-visible device memory" + }, + { + "vuid": "VUID-vkCopyAccelerationStructureToMemoryKHR-pInfo-03732", + "text": " pInfo->dst.hostAddress must be a valid host pointer" + }, + { + "vuid": "VUID-vkCopyAccelerationStructureToMemoryKHR-pInfo-03751", + "text": " pInfo->dst.hostAddress must be aligned to 16 bytes" + }, + { + "vuid": "VUID-vkCopyAccelerationStructureToMemoryKHR-accelerationStructureHostCommands-03584", + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureHostCommands feature must be enabled" + } + ], + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_device_group,VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCopyAccelerationStructureToMemoryKHR-buffer-03783", + "text": " The buffer used to create pInfo->src must be bound to memory that was not allocated with multiple instances" + } + ] + }, + "vkWriteAccelerationStructuresPropertiesKHR": { + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)": [ + { + "vuid": "VUID-vkWriteAccelerationStructuresPropertiesKHR-pAccelerationStructures-04964", + "text": " All acceleration structures in pAccelerationStructures must have been built prior to the execution of this command" + }, + { + "vuid": "VUID-vkWriteAccelerationStructuresPropertiesKHR-accelerationStructures-03431", + "text": " All acceleration structures in pAccelerationStructures must have been built with VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR if queryType is VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR" + }, + { + "vuid": "VUID-vkWriteAccelerationStructuresPropertiesKHR-queryType-03432", + "text": " queryType must be VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR or VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR" + }, + { + "vuid": "VUID-vkWriteAccelerationStructuresPropertiesKHR-queryType-03448", + "text": " If queryType is VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR, then stride must be a multiple of the size of VkDeviceSize" + }, + { + "vuid": "VUID-vkWriteAccelerationStructuresPropertiesKHR-queryType-03449", + "text": " If queryType is VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR, then data must point to a VkDeviceSize" + }, + { + "vuid": "VUID-vkWriteAccelerationStructuresPropertiesKHR-queryType-03450", + "text": " If queryType is VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR, then stride must be a multiple of the size of VkDeviceSize" + }, + { + "vuid": "VUID-vkWriteAccelerationStructuresPropertiesKHR-queryType-03451", + "text": " If queryType is VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR, then data must point to a VkDeviceSize" + }, + { + "vuid": "VUID-vkWriteAccelerationStructuresPropertiesKHR-dataSize-03452", + "text": " dataSize must be greater than or equal to accelerationStructureCount*stride" + }, + { + "vuid": "VUID-vkWriteAccelerationStructuresPropertiesKHR-buffer-03733", + "text": " The buffer used to create each acceleration structure in pAccelerationStructures must be bound to host-visible device memory" + }, + { + "vuid": "VUID-vkWriteAccelerationStructuresPropertiesKHR-accelerationStructureHostCommands-03585", + "text": " The VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructureHostCommands feature must be enabled" + } + ], + "(VK_NV_ray_tracing,VK_KHR_acceleration_structure)+(VK_KHR_device_group,VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkWriteAccelerationStructuresPropertiesKHR-buffer-03784", + "text": " The buffer used to create each acceleration structure in pAccelerationStructures must be bound to memory that was not allocated with multiple instances" + } + ] + }, + "vkCmdTraceRaysNV": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-vkCmdTraceRaysNV-magFilter-04553", + "text": " If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-mipmapMode-04770", + "text": " If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02691", + "text": " If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02699", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-02701", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the VK_NV_inherited_viewport_scissor extension is enabled) for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02705", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02706", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-04115", + "text": " If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-OpImageWrite-04469", + "text": " If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-03429", + "text": " Any shader group handle referenced by this call must have been queried from the currently bound ray tracing pipeline" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-04624", + "text": " commandBuffer must not be a protected command buffer" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-maxRecursionDepth-03625", + "text": " This command must not cause a pipeline trace ray instruction to be executed from a shader invocation with a recursion depth greater than the value of maxRecursionDepth used to create the bound ray tracing pipeline" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-raygenShaderBindingTableBuffer-04042", + "text": " If raygenShaderBindingTableBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-raygenShaderBindingOffset-02455", + "text": " raygenShaderBindingOffset must be less than the size of raygenShaderBindingTableBuffer" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-raygenShaderBindingOffset-02456", + "text": " raygenShaderBindingOffset must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupBaseAlignment" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-missShaderBindingTableBuffer-04043", + "text": " If missShaderBindingTableBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-missShaderBindingOffset-02457", + "text": " missShaderBindingOffset must be less than the size of missShaderBindingTableBuffer" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-missShaderBindingOffset-02458", + "text": " missShaderBindingOffset must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupBaseAlignment" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-hitShaderBindingTableBuffer-04044", + "text": " If hitShaderBindingTableBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-hitShaderBindingOffset-02459", + "text": " hitShaderBindingOffset must be less than the size of hitShaderBindingTableBuffer" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-hitShaderBindingOffset-02460", + "text": " hitShaderBindingOffset must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupBaseAlignment" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-callableShaderBindingTableBuffer-04045", + "text": " If callableShaderBindingTableBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-callableShaderBindingOffset-02461", + "text": " callableShaderBindingOffset must be less than the size of callableShaderBindingTableBuffer" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-callableShaderBindingOffset-02462", + "text": " callableShaderBindingOffset must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupBaseAlignment" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-missShaderBindingStride-02463", + "text": " missShaderBindingStride must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupHandleSize" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-hitShaderBindingStride-02464", + "text": " hitShaderBindingStride must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupHandleSize" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-callableShaderBindingStride-02465", + "text": " callableShaderBindingStride must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupHandleSize" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-missShaderBindingStride-02466", + "text": " missShaderBindingStride must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxShaderGroupStride" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-hitShaderBindingStride-02467", + "text": " hitShaderBindingStride must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxShaderGroupStride" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-callableShaderBindingStride-02468", + "text": " callableShaderBindingStride must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxShaderGroupStride" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-width-02469", + "text": " width must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-height-02470", + "text": " height must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-depth-02471", + "text": " depth must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+!(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdTraceRaysNV-aspectMask-06478", + "text": " If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT." + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdTraceRaysNV-None-06479", + "text": " If a VkImageView is sampled with depth comparison, the image view’s format features must contain VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-OpTypeImage-06423", + "text": " Any VkImageView or VkBufferView being written as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-OpTypeImage-06424", + "text": " Any VkImageView or VkBufferView being read as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02692", + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+!(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02693", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdTraceRaysNV-filterCubic-02694", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-filterCubicMinmax-02695", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-vkCmdTraceRaysNV-flags-02696", + "text": " Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+!(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02698", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdTraceRaysNV-maintenance4-06425", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-02707", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-vkCmdTraceRaysNV-SampledType-04470", + "text": " If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-SampledType-04471", + "text": " If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-SampledType-04472", + "text": " If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-SampledType-04473", + "text": " If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-sparseImageInt64Atomics-04474", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-sparseImageInt64Atomics-04475", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + } + ] + }, + "vkCmdTraceRaysKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-vkCmdTraceRaysKHR-magFilter-04553", + "text": " If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-mipmapMode-04770", + "text": " If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-02691", + "text": " If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-02699", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-commandBuffer-02701", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the VK_NV_inherited_viewport_scissor extension is enabled) for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-02705", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-02706", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-04115", + "text": " If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-OpImageWrite-04469", + "text": " If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-03429", + "text": " Any shader group handle referenced by this call must have been queried from the currently bound ray tracing pipeline" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-maxPipelineRayRecursionDepth-03679", + "text": " This command must not cause a shader call instruction to be executed from a shader invocation with a recursion depth greater than the value of maxPipelineRayRecursionDepth used to create the bound ray tracing pipeline" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-pRayGenShaderBindingTable-03680", + "text": " If the buffer from which pRayGenShaderBindingTable->deviceAddress was queried is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-pRayGenShaderBindingTable-03681", + "text": " The buffer from which the pRayGenShaderBindingTable->deviceAddress is queried must have been created with the VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR usage flag" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-pRayGenShaderBindingTable-03682", + "text": " pRayGenShaderBindingTable->deviceAddress must be a multiple of VkPhysicalDeviceRayTracingPipelinePropertiesKHR::shaderGroupBaseAlignment" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-size-04023", + "text": " The size member of pRayGenShaderBindingTable must be equal to its stride member" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-pMissShaderBindingTable-03683", + "text": " If the buffer from which pMissShaderBindingTable->deviceAddress was queried is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-pMissShaderBindingTable-03684", + "text": " The buffer from which the pMissShaderBindingTable->deviceAddress is queried must have been created with the VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR usage flag" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-pMissShaderBindingTable-03685", + "text": " pMissShaderBindingTable->deviceAddress must be a multiple of VkPhysicalDeviceRayTracingPipelinePropertiesKHR::shaderGroupBaseAlignment" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-stride-03686", + "text": " The stride member of pMissShaderBindingTable must be a multiple of VkPhysicalDeviceRayTracingPipelinePropertiesKHR::shaderGroupHandleAlignment" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-stride-04029", + "text": " The stride member of pMissShaderBindingTable must be less than or equal to VkPhysicalDeviceRayTracingPipelinePropertiesKHR::maxShaderGroupStride" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-pHitShaderBindingTable-03687", + "text": " If the buffer from which pHitShaderBindingTable->deviceAddress was queried is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-pHitShaderBindingTable-03688", + "text": " The buffer from which the pHitShaderBindingTable->deviceAddress is queried must have been created with the VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR usage flag" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-pHitShaderBindingTable-03689", + "text": " pHitShaderBindingTable->deviceAddress must be a multiple of VkPhysicalDeviceRayTracingPipelinePropertiesKHR::shaderGroupBaseAlignment" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-stride-03690", + "text": " The stride member of pHitShaderBindingTable must be a multiple of VkPhysicalDeviceRayTracingPipelinePropertiesKHR::shaderGroupHandleAlignment" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-stride-04035", + "text": " The stride member of pHitShaderBindingTable must be less than or equal to VkPhysicalDeviceRayTracingPipelinePropertiesKHR::maxShaderGroupStride" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-pCallableShaderBindingTable-03691", + "text": " If the buffer from which pCallableShaderBindingTable->deviceAddress was queried is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-pCallableShaderBindingTable-03692", + "text": " The buffer from which the pCallableShaderBindingTable->deviceAddress is queried must have been created with the VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR usage flag" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-pCallableShaderBindingTable-03693", + "text": " pCallableShaderBindingTable->deviceAddress must be a multiple of VkPhysicalDeviceRayTracingPipelinePropertiesKHR::shaderGroupBaseAlignment" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-stride-03694", + "text": " The stride member of pCallableShaderBindingTable must be a multiple of VkPhysicalDeviceRayTracingPipelinePropertiesKHR::shaderGroupHandleAlignment" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-stride-04041", + "text": " The stride member of pCallableShaderBindingTable must be less than or equal to VkPhysicalDeviceRayTracingPipelinePropertiesKHR::maxShaderGroupStride" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-flags-03696", + "text": " If the currently bound ray tracing pipeline was created with flags that included VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR, the deviceAddress member of pHitShaderBindingTable must not be zero" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-flags-03697", + "text": " If the currently bound ray tracing pipeline was created with flags that included VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR, the deviceAddress member of pHitShaderBindingTable must not be zero" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-flags-03511", + "text": " If the currently bound ray tracing pipeline was created with flags that included VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR, the shader group handle identified by pMissShaderBindingTable must not be set to zero" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-flags-03512", + "text": " If the currently bound ray tracing pipeline was created with flags that included VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR, entries in pHitShaderBindingTable accessed as a result of this command in order to execute an any-hit shader must not be set to zero" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-flags-03513", + "text": " If the currently bound ray tracing pipeline was created with flags that included VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR, entries in pHitShaderBindingTable accessed as a result of this command in order to execute a closest hit shader must not be set to zero" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-flags-03514", + "text": " If the currently bound ray tracing pipeline was created with flags that included VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR, entries in pHitShaderBindingTable accessed as a result of this command in order to execute an intersection shader must not be set to zero" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-pHitShaderBindingTable-04735", + "text": " Any non-zero hit shader group entries in pHitShaderBindingTable accessed by this call from a geometry with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR must have been created with VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-pHitShaderBindingTable-04736", + "text": " Any non-zero hit shader group entries in pHitShaderBindingTable accessed by this call from a geometry with a geometryType of VK_GEOMETRY_TYPE_AABBS_KHR must have been created with VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-commandBuffer-04625", + "text": " commandBuffer must not be a protected command buffer" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-width-03626", + "text": " width must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0] {times} VkPhysicalDeviceLimits::maxComputeWorkGroupSize[0]" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-height-03627", + "text": " height must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1] {times} VkPhysicalDeviceLimits::maxComputeWorkGroupSize[1]" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-depth-03628", + "text": " depth must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2] {times} VkPhysicalDeviceLimits::maxComputeWorkGroupSize[2]" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-width-03629", + "text": " width {times} height {times} depth must be less than or equal to VkPhysicalDeviceRayTracingPipelinePropertiesKHR::maxRayDispatchInvocationCount" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdTraceRaysKHR-aspectMask-06478", + "text": " If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT." + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-06479", + "text": " If a VkImageView is sampled with depth comparison, the image view’s format features must contain VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-OpTypeImage-06423", + "text": " Any VkImageView or VkBufferView being written as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-OpTypeImage-06424", + "text": " Any VkImageView or VkBufferView being read as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-02692", + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+!(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-02693", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdTraceRaysKHR-filterCubic-02694", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-filterCubicMinmax-02695", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-vkCmdTraceRaysKHR-flags-02696", + "text": " Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-02698", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdTraceRaysKHR-maintenance4-06425", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdTraceRaysKHR-commandBuffer-02707", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-vkCmdTraceRaysKHR-SampledType-04470", + "text": " If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-SampledType-04471", + "text": " If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-SampledType-04472", + "text": " If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-SampledType-04473", + "text": " If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-sparseImageInt64Atomics-04474", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-sparseImageInt64Atomics-04475", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + } + ] + }, + "VkStridedDeviceAddressRegionKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-VkStridedDeviceAddressRegionKHR-size-04631", + "text": " If size is not zero, all addresses between deviceAddress and deviceAddress + size - 1 must be in the buffer device address range of the same buffer" + }, + { + "vuid": "VUID-VkStridedDeviceAddressRegionKHR-size-04632", + "text": " If size is not zero, stride must be less than or equal to the size of the buffer from which deviceAddress was queried" + } + ] + }, + "vkCmdBindInvocationMaskHUAWEI": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_HUAWEI_invocation_mask)": [ + { + "vuid": "VUID-vkCmdBindInvocationMaskHUAWEI-None-04976", + "text": " The invocation mask image feature must be enabled" + }, + { + "vuid": "VUID-vkCmdBindInvocationMaskHUAWEI-imageView-04977", + "text": " If imageView is not VK_NULL_HANDLE, it must be a valid VkImageView handle of type VK_IMAGE_VIEW_TYPE_2D" + }, + { + "vuid": "VUID-vkCmdBindInvocationMaskHUAWEI-imageView-04978", + "text": " If imageView is not VK_NULL_HANDLE, it must have a format of VK_FORMAT_R8_UINT" + }, + { + "vuid": "VUID-vkCmdBindInvocationMaskHUAWEI-imageView-04979", + "text": " If imageView is not VK_NULL_HANDLE, it must have been created with VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI set" + }, + { + "vuid": "VUID-vkCmdBindInvocationMaskHUAWEI-imageView-04980", + "text": " If imageView is not VK_NULL_HANDLE, imageLayout must be VK_IMAGE_LAYOUT_GENERAL" + }, + { + "vuid": "VUID-vkCmdBindInvocationMaskHUAWEI-width-04981", + "text": " Thread mask image resolution must match the width and height in vkCmdTraceRaysKHR" + }, + { + "vuid": "VUID-vkCmdBindInvocationMaskHUAWEI-None-04982", + "text": " Each element in the invocation mask image must have the value 0 or 1. The value 1 means the invocation is active" + }, + { + "vuid": "VUID-vkCmdBindInvocationMaskHUAWEI-width-04983", + "text": " width in vkCmdTraceRaysKHR should be 1" + } + ] + }, + "vkCmdTraceRaysIndirectKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-magFilter-04553", + "text": " If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-mipmapMode-04770", + "text": " If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02691", + "text": " If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02699", + "text": " Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-commandBuffer-02701", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the VK_NV_inherited_viewport_scissor extension is enabled) for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02705", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02706", + "text": " If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-04115", + "text": " If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-OpImageWrite-04469", + "text": " If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-03429", + "text": " Any shader group handle referenced by this call must have been queried from the currently bound ray tracing pipeline" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-maxPipelineRayRecursionDepth-03679", + "text": " This command must not cause a shader call instruction to be executed from a shader invocation with a recursion depth greater than the value of maxPipelineRayRecursionDepth used to create the bound ray tracing pipeline" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-pRayGenShaderBindingTable-03680", + "text": " If the buffer from which pRayGenShaderBindingTable->deviceAddress was queried is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-pRayGenShaderBindingTable-03681", + "text": " The buffer from which the pRayGenShaderBindingTable->deviceAddress is queried must have been created with the VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR usage flag" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-pRayGenShaderBindingTable-03682", + "text": " pRayGenShaderBindingTable->deviceAddress must be a multiple of VkPhysicalDeviceRayTracingPipelinePropertiesKHR::shaderGroupBaseAlignment" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-size-04023", + "text": " The size member of pRayGenShaderBindingTable must be equal to its stride member" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-pMissShaderBindingTable-03683", + "text": " If the buffer from which pMissShaderBindingTable->deviceAddress was queried is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-pMissShaderBindingTable-03684", + "text": " The buffer from which the pMissShaderBindingTable->deviceAddress is queried must have been created with the VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR usage flag" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-pMissShaderBindingTable-03685", + "text": " pMissShaderBindingTable->deviceAddress must be a multiple of VkPhysicalDeviceRayTracingPipelinePropertiesKHR::shaderGroupBaseAlignment" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-stride-03686", + "text": " The stride member of pMissShaderBindingTable must be a multiple of VkPhysicalDeviceRayTracingPipelinePropertiesKHR::shaderGroupHandleAlignment" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-stride-04029", + "text": " The stride member of pMissShaderBindingTable must be less than or equal to VkPhysicalDeviceRayTracingPipelinePropertiesKHR::maxShaderGroupStride" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-pHitShaderBindingTable-03687", + "text": " If the buffer from which pHitShaderBindingTable->deviceAddress was queried is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-pHitShaderBindingTable-03688", + "text": " The buffer from which the pHitShaderBindingTable->deviceAddress is queried must have been created with the VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR usage flag" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-pHitShaderBindingTable-03689", + "text": " pHitShaderBindingTable->deviceAddress must be a multiple of VkPhysicalDeviceRayTracingPipelinePropertiesKHR::shaderGroupBaseAlignment" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-stride-03690", + "text": " The stride member of pHitShaderBindingTable must be a multiple of VkPhysicalDeviceRayTracingPipelinePropertiesKHR::shaderGroupHandleAlignment" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-stride-04035", + "text": " The stride member of pHitShaderBindingTable must be less than or equal to VkPhysicalDeviceRayTracingPipelinePropertiesKHR::maxShaderGroupStride" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-pCallableShaderBindingTable-03691", + "text": " If the buffer from which pCallableShaderBindingTable->deviceAddress was queried is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-pCallableShaderBindingTable-03692", + "text": " The buffer from which the pCallableShaderBindingTable->deviceAddress is queried must have been created with the VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR usage flag" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-pCallableShaderBindingTable-03693", + "text": " pCallableShaderBindingTable->deviceAddress must be a multiple of VkPhysicalDeviceRayTracingPipelinePropertiesKHR::shaderGroupBaseAlignment" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-stride-03694", + "text": " The stride member of pCallableShaderBindingTable must be a multiple of VkPhysicalDeviceRayTracingPipelinePropertiesKHR::shaderGroupHandleAlignment" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-stride-04041", + "text": " The stride member of pCallableShaderBindingTable must be less than or equal to VkPhysicalDeviceRayTracingPipelinePropertiesKHR::maxShaderGroupStride" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-flags-03696", + "text": " If the currently bound ray tracing pipeline was created with flags that included VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR, the deviceAddress member of pHitShaderBindingTable must not be zero" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-flags-03697", + "text": " If the currently bound ray tracing pipeline was created with flags that included VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR, the deviceAddress member of pHitShaderBindingTable must not be zero" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-flags-03511", + "text": " If the currently bound ray tracing pipeline was created with flags that included VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR, the shader group handle identified by pMissShaderBindingTable must not be set to zero" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-flags-03512", + "text": " If the currently bound ray tracing pipeline was created with flags that included VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR, entries in pHitShaderBindingTable accessed as a result of this command in order to execute an any-hit shader must not be set to zero" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-flags-03513", + "text": " If the currently bound ray tracing pipeline was created with flags that included VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR, entries in pHitShaderBindingTable accessed as a result of this command in order to execute a closest hit shader must not be set to zero" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-flags-03514", + "text": " If the currently bound ray tracing pipeline was created with flags that included VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR, entries in pHitShaderBindingTable accessed as a result of this command in order to execute an intersection shader must not be set to zero" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-pHitShaderBindingTable-04735", + "text": " Any non-zero hit shader group entries in pHitShaderBindingTable accessed by this call from a geometry with a geometryType of VK_GEOMETRY_TYPE_TRIANGLES_KHR must have been created with VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-pHitShaderBindingTable-04736", + "text": " Any non-zero hit shader group entries in pHitShaderBindingTable accessed by this call from a geometry with a geometryType of VK_GEOMETRY_TYPE_AABBS_KHR must have been created with VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-indirectDeviceAddress-03632", + "text": " If the buffer from which indirectDeviceAddress was queried is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-indirectDeviceAddress-03633", + "text": " The buffer from which indirectDeviceAddress was queried must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-indirectDeviceAddress-03634", + "text": " indirectDeviceAddress must be a multiple of 4" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-commandBuffer-03635", + "text": " commandBuffer must not be a protected command buffer" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-indirectDeviceAddress-03636", + "text": " All device addresses between indirectDeviceAddress and indirectDeviceAddress + sizeof(VkTraceRaysIndirectCommandKHR) - 1 must be in the buffer device address range of the same buffer" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-rayTracingPipelineTraceRaysIndirect-03637", + "text": " The VkPhysicalDeviceRayTracingPipelineFeaturesKHR::rayTracingPipelineTraceRaysIndirect feature must be enabled" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-aspectMask-06478", + "text": " If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT." + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-06479", + "text": " If a VkImageView is sampled with depth comparison, the image view’s format features must contain VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-OpTypeImage-06423", + "text": " Any VkImageView or VkBufferView being written as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-OpTypeImage-06424", + "text": " Any VkImageView or VkBufferView being read as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown must have image format features that support VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02692", + "text": " If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+!(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02693", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_IMG_filter_cubic,VK_EXT_filter_cubic)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-filterCubic-02694", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-filterCubicMinmax-02695", + "text": " Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_NV_corner_sampled_image)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-flags-02696", + "text": " Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02698", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-maintenance4-06425", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-commandBuffer-02707", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-SampledType-04470", + "text": " If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-SampledType-04471", + "text": " If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-SampledType-04472", + "text": " If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-SampledType-04473", + "text": " If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-sparseImageInt64Atomics-04474", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-sparseImageInt64Atomics-04475", + "text": " If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing_motion_blur)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-rayTracingMotionBlurPipelineTraceRaysIndirect-04951", + "text": " If the bound ray tracing pipeline was created with VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV VkPhysicalDeviceRayTracingMotionBlurFeaturesNV::rayTracingMotionBlurPipelineTraceRaysIndirect feature must be enabled" + } + ] + }, + "VkTraceRaysIndirectCommandKHR": { + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-VkTraceRaysIndirectCommandKHR-width-03638", + "text": " width must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0] {times} VkPhysicalDeviceLimits::maxComputeWorkGroupSize[0]" + }, + { + "vuid": "VUID-VkTraceRaysIndirectCommandKHR-height-03639", + "text": " height must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1] {times} VkPhysicalDeviceLimits::maxComputeWorkGroupSize[1]" + }, + { + "vuid": "VUID-VkTraceRaysIndirectCommandKHR-depth-03640", + "text": " depth must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2] {times} VkPhysicalDeviceLimits::maxComputeWorkGroupSize[2]" + }, + { + "vuid": "VUID-VkTraceRaysIndirectCommandKHR-width-03641", + "text": " width {times} height {times} depth must be less than or equal to VkPhysicalDeviceRayTracingPipelinePropertiesKHR::maxRayDispatchInvocationCount" + } + ] + }, + "vkGetPhysicalDeviceVideoFormatPropertiesKHR": { + "(VK_KHR_video_queue)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceVideoFormatPropertiesKHR-imageUsage-04844", + "text": " The imageUsage enum of VkPhysicalDeviceVideoFormatInfoKHR must contain at least one of the following video image usage bit(s): VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR, VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR, VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR, or VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR" + } + ] + }, + "VkVideoSessionCreateInfoKHR": { + "(VK_KHR_video_queue)": [ + { + "vuid": "VUID-VkVideoSessionCreateInfoKHR-pVideoProfile-04845", + "text": " pVideoProfile must be a pointer to a valid VkVideoProfileKHR structure whose pNext chain must include a valid codec-specific profile structure" + }, + { + "vuid": "VUID-VkVideoSessionCreateInfoKHR-maxReferencePicturesSlotsCount-04846", + "text": " If Reference Pictures are required for use with the created video session, the maxReferencePicturesSlotsCount must be set to a value bigger than 0" + }, + { + "vuid": "VUID-VkVideoSessionCreateInfoKHR-maxReferencePicturesSlotsCount-04847", + "text": " maxReferencePicturesSlotsCount cannot exceed the implementation reported VkVideoCapabilitiesKHR::maxReferencePicturesSlotsCount" + }, + { + "vuid": "VUID-VkVideoSessionCreateInfoKHR-maxReferencePicturesActiveCount-04848", + "text": " If Reference Pictures are required for use with the created video session, the maxReferencePicturesActiveCount must be set to a value bigger than 0" + }, + { + "vuid": "VUID-VkVideoSessionCreateInfoKHR-maxReferencePicturesActiveCount-04849", + "text": " maxReferencePicturesActiveCount cannot exceed the implementation reported VkVideoCapabilitiesKHR::maxReferencePicturesActiveCount" + }, + { + "vuid": "VUID-VkVideoSessionCreateInfoKHR-maxReferencePicturesActiveCount-04850", + "text": " maxReferencePicturesActiveCount cannot exceed the maxReferencePicturesSlotsCount" + }, + { + "vuid": "VUID-VkVideoSessionCreateInfoKHR-maxCodedExtent-04851", + "text": " maxCodedExtent cannot be smaller than VkVideoCapabilitiesKHR::minExtent and bigger than VkVideoCapabilitiesKHR::maxExtent" + }, + { + "vuid": "VUID-VkVideoSessionCreateInfoKHR-referencePicturesFormat-04852", + "text": " referencePicturesFormat must be one of the supported formats in VkVideoFormatPropertiesKHR format returned by the vkGetPhysicalDeviceVideoFormatPropertiesKHR when the VkPhysicalDeviceVideoFormatInfoKHR imageUsage contains VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR or VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR depending on the session codec operation" + }, + { + "vuid": "VUID-VkVideoSessionCreateInfoKHR-pictureFormat-04853", + "text": " pictureFormat for decode output must be one of the supported formats in VkVideoFormatPropertiesKHR format returned by the vkGetPhysicalDeviceVideoFormatPropertiesKHR when the VkPhysicalDeviceVideoFormatInfoKHR imageUsage contains VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR" + }, + { + "vuid": "VUID-VkVideoSessionCreateInfoKHR-pictureFormat-04854", + "text": " pictureFormat targeting encode operations must be one of the supported formats in VkVideoFormatPropertiesKHR format returned by the vkGetPhysicalDeviceVideoFormatPropertiesKHR when the VkPhysicalDeviceVideoFormatInfoKHR imageUsage contains VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR" + } + ] + }, + "VkVideoSessionParametersCreateInfoKHR": { + "(VK_KHR_video_queue)": [ + { + "vuid": "VUID-VkVideoSessionParametersCreateInfoKHR-videoSessionParametersTemplate-04855", + "text": " If videoSessionParametersTemplate represents a valid handle, it must have been created against videoSession" + } + ] + }, + "VkVideoBeginCodingInfoKHR": { + "(VK_KHR_video_queue)": [ + { + "vuid": "VUID-VkVideoBeginCodingInfoKHR-referenceSlotCount-04856", + "text": " VkVideoBeginCodingInfoKHR::referenceSlotCount must not exceed the value specified in VkVideoSessionCreateInfoKHR::maxReferencePicturesSlotsCount when creating the video session object that is being provided in videoSession" + }, + { + "vuid": "VUID-VkVideoBeginCodingInfoKHR-videoSessionParameters-04857", + "text": " If videoSessionParameters is not VK_NULL_HANDLE, it must have been created using videoSession as a parent object" + } + ] + }, + "VkVideoDecodeH264ProfileEXT": { + "(VK_EXT_video_decode_h264)": [ + { + "vuid": "VUID-VkVideoDecodeH264ProfileEXT-pNext-06259", + "text": " If the VkVideoDecodeH264ProfileEXT structure is included in the pNext chain of the VkVideoCapabilitiesKHR structure passed to vkGetPhysicalDeviceVideoCapabilitiesKHR, the value in pictureLayout is treated as a bitmask of requested picture layouts. It is always valid to use the value VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_EXT as the implementation is guaranteed to support decoding of progressive content." + }, + { + "vuid": "VUID-VkVideoDecodeH264ProfileEXT-pNext-06260", + "text": " If the VkVideoDecodeH264ProfileEXT structure is included in the pNext chain of the VkVideoSessionCreateInfoKHR structure passed to vkCreateVideoSessionKHR, the value in pictureLayout must be exactly one of VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_EXT, VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_EXT or VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_EXT." + } + ] + }, + "VkVideoDecodeH264SessionParametersAddInfoEXT": { + "(VK_EXT_video_decode_h264)": [ + { + "vuid": "VUID-VkVideoDecodeH264SessionParametersAddInfoEXT-spsStdCount-04822", + "text": " The values of spsStdCount and ppsStdCount must be less than or equal to the values of maxSpsStdCount and maxPpsStdCount, respectively" + }, + { + "vuid": "VUID-VkVideoDecodeH264SessionParametersAddInfoEXT-maxSpsStdCount-04823", + "text": " When the maxSpsStdCount number of parameters of type StdVideoH264SequenceParameterSet in the Video Session Parameters object is reached, no additional parameters of that type can be added to this object. VK_ERROR_TOO_MANY_OBJECTS will be returned if an attempt is made to add additional data to this object at this point" + }, + { + "vuid": "VUID-VkVideoDecodeH264SessionParametersAddInfoEXT-maxPpsStdCount-04824", + "text": " When the maxPpsStdCount number of parameters of type StdVideoH264PictureParameterSet in the Video Session Parameters object is reached, no additional parameters of that type can be added to this object. VK_ERROR_TOO_MANY_OBJECTS will be returned if an attempt is made to add additional data to this object at this point" + }, + { + "vuid": "VUID-VkVideoDecodeH264SessionParametersAddInfoEXT-None-04825", + "text": " Each entry to be added must have a unique, to the rest of the parameter array entries and the existing parameters in the Video Session Parameters Object that is being updated, SPS-PPS IDs" + }, + { + "vuid": "VUID-VkVideoDecodeH264SessionParametersAddInfoEXT-None-04826", + "text": " Parameter entries that already exist in Video Session Parameters object with a particular SPS-PPS IDs cannot be replaced nor updated" + }, + { + "vuid": "VUID-VkVideoDecodeH264SessionParametersAddInfoEXT-None-04827", + "text": " When creating a new object using a Video Session Parameters as a template, the array’s parameters with the same SPS-PPS IDs as the ones from the template take precedence" + }, + { + "vuid": "VUID-VkVideoDecodeH264SessionParametersAddInfoEXT-None-04828", + "text": " SPS/PPS parameters must comply with the limits specified in VkVideoSessionCreateInfoKHR during Video Session creation" + } + ] + }, + "VkVideoDecodeH265SessionParametersAddInfoEXT": { + "(VK_EXT_video_decode_h265)": [ + { + "vuid": "VUID-VkVideoDecodeH265SessionParametersAddInfoEXT-vpsStdCount-04829", + "text": " The values of vpsStdCount, spsStdCount and ppsStdCount must be less than or equal to the values of maxVpsStdCount, maxSpsStdCount and maxPpsStdCount, respectively" + }, + { + "vuid": "VUID-VkVideoDecodeH265SessionParametersAddInfoEXT-maxVpsStdCount-04830", + "text": " When the maxVpsStdCount number of parameters of type StdVideoH265VideoParameterSet in the Video Session Parameters object is reached, no additional parameters of that type can be added to the object. VK_ERROR_TOO_MANY_OBJECTS will be returned if an attempt is made to add additional data to this object at this point" + }, + { + "vuid": "VUID-VkVideoDecodeH265SessionParametersAddInfoEXT-maxSpsStdCount-04831", + "text": " When the maxSpsStdCount number of parameters of type StdVideoH265SequenceParameterSet in the Video Session Parameters object is reached, no additional parameters of that type can be added to the object. VK_ERROR_TOO_MANY_OBJECTS will be returned if an attempt is made to add additional data to this object at this point" + }, + { + "vuid": "VUID-VkVideoDecodeH265SessionParametersAddInfoEXT-maxPpsStdCount-04832", + "text": " When the maxPpsStdCount number of parameters of type StdVideoH265PictureParameterSet in the Video Session Parameters object is reached, no additional parameters of that type can be added to the object. VK_ERROR_TOO_MANY_OBJECTS will be returned if an attempt is made to add additional data to this object at this point" + }, + { + "vuid": "VUID-VkVideoDecodeH265SessionParametersAddInfoEXT-None-04833", + "text": " Each entry to be added must have a unique, to the rest of the parameter array entries and the existing parameters in the Video Session Parameters Object that is being updated, VPS-SPS-PPS IDs" + }, + { + "vuid": "VUID-VkVideoDecodeH265SessionParametersAddInfoEXT-None-04834", + "text": " Parameter entries that already exist in Video Session Parameters object with a particular VPS-SPS-PPS IDs cannot be replaced nor updated" + }, + { + "vuid": "VUID-VkVideoDecodeH265SessionParametersAddInfoEXT-None-04835", + "text": " When creating a new object using a Video Session Parameters as a template, the array’s parameters with the same VPS-SPS-PPS IDs as the ones from the template take precedence" + }, + { + "vuid": "VUID-VkVideoDecodeH265SessionParametersAddInfoEXT-None-04836", + "text": " VPS/SPS/PPS parameters must comply with the limits specified in VkVideoSessionCreateInfoKHR during Video Session creation" + } + ] + }, + "VkVideoEncodeH264SessionParametersAddInfoEXT": { + "(VK_EXT_video_encode_h264)": [ + { + "vuid": "VUID-VkVideoEncodeH264SessionParametersAddInfoEXT-spsStdCount-04837", + "text": " The values of spsStdCount and ppsStdCount must be less than or equal to the values of maxSpsStdCount and maxPpsStdCount, respectively" + }, + { + "vuid": "VUID-VkVideoEncodeH264SessionParametersAddInfoEXT-maxSpsStdCount-04838", + "text": " When the maxSpsStdCount number of parameters of type StdVideoH264SequenceParameterSet in the Video Session Parameters object is reached, no additional parameters of that type can be added to the object. VK_ERROR_TOO_MANY_OBJECTS will be returned if an attempt is made to add additional data to this object at this point" + }, + { + "vuid": "VUID-VkVideoEncodeH264SessionParametersAddInfoEXT-maxPpsStdCount-04839", + "text": " When the maxPpsStdCount number of parameters of type StdVideoH264PictureParameterSet in the Video Session Parameters object is reached, no additional parameters of that type can be added to the object. VK_ERROR_TOO_MANY_OBJECTS will be returned if an attempt is made to add additional data to this object at this point" + }, + { + "vuid": "VUID-VkVideoEncodeH264SessionParametersAddInfoEXT-None-04840", + "text": " Each entry to be added must have a unique, to the rest of the parameter array entries and the existing parameters in the Video Session Parameters Object that is being updated, SPS-PPS IDs" + }, + { + "vuid": "VUID-VkVideoEncodeH264SessionParametersAddInfoEXT-None-04841", + "text": " Parameter entries that already exist in Video Session Parameters object with a particular SPS-PPS IDs cannot be replaced nor updated" + }, + { + "vuid": "VUID-VkVideoEncodeH264SessionParametersAddInfoEXT-None-04842", + "text": " When creating a new object using a Video Session Parameters as a template, the array’s parameters with the same SPS-PPS IDs as the ones from the template take precedence" + }, + { + "vuid": "VUID-VkVideoEncodeH264SessionParametersAddInfoEXT-None-04843", + "text": " SPS/PPS parameters must comply with the limits specified in VkVideoSessionCreateInfoKHR during Video Session creation" + } + ] + }, + "VkVideoEncodeH264RateControlLayerInfoEXT": { + "(VK_EXT_video_encode_h264)": [ + { + "vuid": "VUID-VkVideoEncodeH264RateControlLayerInfoEXT-rateControlMode-06474", + "text": " When VkVideoEncodeRateControlInfoKHR::rateControlMode is VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR, both useMinQp and useMaxQp must be set to VK_TRUE." + }, + { + "vuid": "VUID-VkVideoEncodeH264RateControlLayerInfoEXT-rateControlMode-06475", + "text": " When VkVideoEncodeRateControlInfoKHR::rateControlMode is VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR, the values provided in minQP must be identical to those provided in maxQp." + } + ] + }, + "VkVideoEncodeH265SessionParametersAddInfoEXT": { + "(VK_EXT_video_encode_h265)": [ + { + "vuid": "VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-vpsStdCount-06438", + "text": " The values of vpsStdCount, spsStdCount and ppsStdCount must be less than or equal to the values of VkVideoEncodeH265SessionParametersCreateInfoEXT::maxVpsStdCount, VkVideoEncodeH265SessionParametersCreateInfoEXT:maxSpsStdCount, and VkVideoEncodeH265SessionParametersCreateInfoEXT:maxPpsStdCount, respectively" + }, + { + "vuid": "VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-pVpsStd-06439", + "text": " Each StdVideoH265VideoParameterSet entry in pVpsStd must have a unique H.265 VPS ID" + }, + { + "vuid": "VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-pSpsStd-06440", + "text": " Each StdVideoH265SequenceParameterSet entry in pSpsStd must have a unique H.265 VPS-SPS ID pair" + }, + { + "vuid": "VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-pPpsStd-06441", + "text": " Each StdVideoH265PictureParameterSet entry in pPpsStd must have a unique H.265 VPS-SPS-PPS ID tuple" + }, + { + "vuid": "VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-None-06442", + "text": " Each entry to be added must have a unique, to the rest of the parameter array entries and the existing parameters in the Video Session Parameters Object that is being updated, VPS-SPS-PPS IDs" + }, + { + "vuid": "VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-None-06443", + "text": " Parameter entries that already exist in Video Session Parameters object with a particular VPS-SPS-PPS IDs must not be replaced nor updated" + }, + { + "vuid": "VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-None-06444", + "text": " When creating a new object using a Video Session Parameters as a template, the array’s parameters with the same VPS-SPS-PPS IDs as the ones from the template take precedence" + }, + { + "vuid": "VUID-VkVideoEncodeH265SessionParametersAddInfoEXT-None-06445", + "text": " VPS/SPS/PPS parameters must comply with the limits specified in VkVideoSessionCreateInfoKHR during Video Session creation" + } + ] + }, + "VkVideoEncodeH265RateControlLayerInfoEXT": { + "(VK_EXT_video_encode_h265)": [ + { + "vuid": "VUID-VkVideoEncodeH265RateControlLayerInfoEXT-rateControlMode-06476", + "text": " When VkVideoEncodeRateControlInfoKHR::rateControlMode is VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR, both useMinQp and useMaxQp must be set to VK_TRUE." + }, + { + "vuid": "VUID-VkVideoEncodeH265RateControlLayerInfoEXT-rateControlMode-06477", + "text": " When VkVideoEncodeRateControlInfoKHR::rateControlMode is VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR, the values provided in minQP must be identical to those provided in maxQp." + } + ] + }, + "vkEnumerateInstanceLayerProperties": { + "core": [ + { + "vuid": "VUID-vkEnumerateInstanceLayerProperties-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkEnumerateInstanceLayerProperties-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkLayerProperties structures" + } + ] + }, + "vkEnumerateDeviceLayerProperties": { + "core": [ + { + "vuid": "VUID-vkEnumerateDeviceLayerProperties-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkEnumerateDeviceLayerProperties-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkEnumerateDeviceLayerProperties-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkLayerProperties structures" + } + ] + }, + "vkEnumerateInstanceExtensionProperties": { + "core": [ + { + "vuid": "VUID-vkEnumerateInstanceExtensionProperties-pLayerName-parameter", + "text": " If pLayerName is not NULL, pLayerName must be a null-terminated UTF-8 string" + }, + { + "vuid": "VUID-vkEnumerateInstanceExtensionProperties-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkEnumerateInstanceExtensionProperties-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkExtensionProperties structures" + } + ] + }, + "vkEnumerateDeviceExtensionProperties": { + "core": [ + { + "vuid": "VUID-vkEnumerateDeviceExtensionProperties-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkEnumerateDeviceExtensionProperties-pLayerName-parameter", + "text": " If pLayerName is not NULL, pLayerName must be a null-terminated UTF-8 string" + }, + { + "vuid": "VUID-vkEnumerateDeviceExtensionProperties-pPropertyCount-parameter", + "text": " pPropertyCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkEnumerateDeviceExtensionProperties-pProperties-parameter", + "text": " If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pPropertyCount VkExtensionProperties structures" + } + ] + }, + "vkGetPhysicalDeviceFeatures": { + "core": [ + { + "vuid": "VUID-vkGetPhysicalDeviceFeatures-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceFeatures-pFeatures-parameter", + "text": " pFeatures must be a valid pointer to a VkPhysicalDeviceFeatures structure" + } + ] + }, + "vkGetPhysicalDeviceFeatures2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceFeatures2-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceFeatures2-pFeatures-parameter", + "text": " pFeatures must be a valid pointer to a VkPhysicalDeviceFeatures2 structure" + } + ] + }, + "VkPhysicalDeviceFeatures2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkPhysicalDeviceFeatures2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2" + } + ] + }, + "VkPhysicalDeviceVulkan11Features": { + "(VK_VERSION_1_2)": [ + { + "vuid": "VUID-VkPhysicalDeviceVulkan11Features-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES" + } + ] + }, + "VkPhysicalDeviceVulkan12Features": { + "(VK_VERSION_1_2)": [ + { + "vuid": "VUID-VkPhysicalDeviceVulkan12Features-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES" + } + ] + }, + "VkPhysicalDeviceVariablePointersFeatures": { + "(VK_VERSION_1_1,VK_KHR_variable_pointers)": [ + { + "vuid": "VUID-VkPhysicalDeviceVariablePointersFeatures-variablePointers-01431", + "text": " If variablePointers is enabled then variablePointersStorageBuffer must also be enabled" + }, + { + "vuid": "VUID-VkPhysicalDeviceVariablePointersFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES" + } + ] + }, + "VkPhysicalDeviceMultiviewFeatures": { + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkPhysicalDeviceMultiviewFeatures-multiviewGeometryShader-00580", + "text": " If multiviewGeometryShader is enabled then multiview must also be enabled" + }, + { + "vuid": "VUID-VkPhysicalDeviceMultiviewFeatures-multiviewTessellationShader-00581", + "text": " If multiviewTessellationShader is enabled then multiview must also be enabled" + }, + { + "vuid": "VUID-VkPhysicalDeviceMultiviewFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES" + } + ] + }, + "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT": { + "(VK_EXT_shader_atomic_float)": [ + { + "vuid": "VUID-VkPhysicalDeviceShaderAtomicFloatFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceShaderAtomicInt64Features": { + "(VK_VERSION_1_2,VK_KHR_shader_atomic_int64)": [ + { + "vuid": "VUID-VkPhysicalDeviceShaderAtomicInt64Features-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES" + } + ] + }, + "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT": { + "(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT" + } + ] + }, + "VkPhysicalDevice8BitStorageFeatures": { + "(VK_VERSION_1_2,VK_KHR_8bit_storage)": [ + { + "vuid": "VUID-VkPhysicalDevice8BitStorageFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES" + } + ] + }, + "VkPhysicalDevice16BitStorageFeatures": { + "(VK_VERSION_1_1,VK_KHR_16bit_storage)": [ + { + "vuid": "VUID-VkPhysicalDevice16BitStorageFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES" + } + ] + }, + "VkPhysicalDeviceShaderFloat16Int8Features": { + "(VK_VERSION_1_2,VK_KHR_shader_float16_int8)": [ + { + "vuid": "VUID-VkPhysicalDeviceShaderFloat16Int8Features-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES" + } + ] + }, + "VkPhysicalDeviceShaderClockFeaturesKHR": { + "(VK_KHR_shader_clock)": [ + { + "vuid": "VUID-VkPhysicalDeviceShaderClockFeaturesKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR" + } + ] + }, + "VkPhysicalDeviceSamplerYcbcrConversionFeatures": { + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkPhysicalDeviceSamplerYcbcrConversionFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES" + } + ] + }, + "VkPhysicalDeviceProtectedMemoryFeatures": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkPhysicalDeviceProtectedMemoryFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES" + } + ] + }, + "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT": { + "(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceShaderDrawParametersFeatures": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkPhysicalDeviceShaderDrawParametersFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES" + } + ] + }, + "VkPhysicalDeviceDescriptorIndexingFeatures": { + "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkPhysicalDeviceDescriptorIndexingFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES" + } + ] + }, + "VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT": { + "(VK_EXT_vertex_attribute_divisor)": [ + { + "vuid": "VUID-VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceASTCDecodeFeaturesEXT": { + "(VK_EXT_astc_decode_mode)": [ + { + "vuid": "VUID-VkPhysicalDeviceASTCDecodeFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceVulkanMemoryModelFeatures": { + "(VK_VERSION_1_2,VK_KHR_vulkan_memory_model)": [ + { + "vuid": "VUID-VkPhysicalDeviceVulkanMemoryModelFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES" + } + ] + }, + "VkPhysicalDeviceScalarBlockLayoutFeatures": { + "(VK_VERSION_1_2,VK_EXT_scalar_block_layout)": [ + { + "vuid": "VUID-VkPhysicalDeviceScalarBlockLayoutFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES" + } + ] + }, + "VkPhysicalDeviceUniformBufferStandardLayoutFeatures": { + "(VK_VERSION_1_2,VK_KHR_uniform_buffer_standard_layout)": [ + { + "vuid": "VUID-VkPhysicalDeviceUniformBufferStandardLayoutFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES" + } + ] + }, + "VkPhysicalDeviceDepthClipEnableFeaturesEXT": { + "(VK_EXT_depth_clip_enable)": [ + { + "vuid": "VUID-VkPhysicalDeviceDepthClipEnableFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceBufferDeviceAddressFeatures": { + "(VK_VERSION_1_2,VK_KHR_buffer_device_address)": [ + { + "vuid": "VUID-VkPhysicalDeviceBufferDeviceAddressFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES" + } + ] + }, + "VkPhysicalDeviceImagelessFramebufferFeatures": { + "(VK_VERSION_1_2,VK_KHR_imageless_framebuffer)": [ + { + "vuid": "VUID-VkPhysicalDeviceImagelessFramebufferFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES" + } + ] + }, + "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT": { + "(VK_EXT_fragment_shader_interlock)": [ + { + "vuid": "VUID-VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT": { + "(VK_EXT_ycbcr_image_arrays)": [ + { + "vuid": "VUID-VkPhysicalDeviceYcbcrImageArraysFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures": { + "(VK_VERSION_1_1)+(VK_VERSION_1_2,VK_KHR_shader_subgroup_extended_types)": [ + { + "vuid": "VUID-VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES" + } + ] + }, + "VkPhysicalDeviceHostQueryResetFeatures": { + "(VK_VERSION_1_2,VK_EXT_host_query_reset)": [ + { + "vuid": "VUID-VkPhysicalDeviceHostQueryResetFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES" + } + ] + }, + "VkPhysicalDeviceTimelineSemaphoreFeatures": { + "(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-VkPhysicalDeviceTimelineSemaphoreFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES" + } + ] + }, + "VkPhysicalDeviceIndexTypeUint8FeaturesEXT": { + "(VK_EXT_index_type_uint8)": [ + { + "vuid": "VUID-VkPhysicalDeviceIndexTypeUint8FeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures": { + "(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ + { + "vuid": "VUID-VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES" + } + ] + }, + "VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT": { + "(VK_EXT_shader_demote_to_helper_invocation)": [ + { + "vuid": "VUID-VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT": { + "(VK_EXT_texel_buffer_alignment)": [ + { + "vuid": "VUID-VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT": { + "(VK_EXT_texture_compression_astc_hdr)": [ + { + "vuid": "VUID-VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceLineRasterizationFeaturesEXT": { + "(VK_EXT_line_rasterization)": [ + { + "vuid": "VUID-VkPhysicalDeviceLineRasterizationFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceSubgroupSizeControlFeaturesEXT": { + "(VK_EXT_subgroup_size_control)": [ + { + "vuid": "VUID-VkPhysicalDeviceSubgroupSizeControlFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceRayTracingPipelineFeaturesKHR": { + "(VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-VkPhysicalDeviceRayTracingPipelineFeaturesKHR-rayTracingPipelineShaderGroupHandleCaptureReplayMixed-03575", + "text": " If rayTracingPipelineShaderGroupHandleCaptureReplayMixed is VK_TRUE, rayTracingPipelineShaderGroupHandleCaptureReplay must also be VK_TRUE" + } + ] + }, + "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT": { + "(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-VkPhysicalDeviceExtendedDynamicStateFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT": { + "(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-VkPhysicalDeviceExtendedDynamicState2FeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceRobustness2FeaturesEXT": { + "(VK_EXT_robustness2)": [ + { + "vuid": "VUID-VkPhysicalDeviceRobustness2FeaturesEXT-robustBufferAccess2-04000", + "text": " If robustBufferAccess2 is enabled then robustBufferAccess must also be enabled" + }, + { + "vuid": "VUID-VkPhysicalDeviceRobustness2FeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceImageRobustnessFeaturesEXT": { + "(VK_EXT_image_robustness)": [ + { + "vuid": "VUID-VkPhysicalDeviceImageRobustnessFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR": { + "(VK_KHR_shader_terminate_invocation)": [ + { + "vuid": "VUID-VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR" + } + ] + }, + "VkPhysicalDeviceCustomBorderColorFeaturesEXT": { + "(VK_EXT_custom_border_color)": [ + { + "vuid": "VUID-VkPhysicalDeviceCustomBorderColorFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceVulkanSC10Features": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkPhysicalDeviceVulkanSC10Features-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES" + } + ] + }, + "VkPhysicalDevicePerformanceQueryFeaturesKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-VkPhysicalDevicePerformanceQueryFeaturesKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR" + } + ] + }, + "VkPhysicalDevice4444FormatsFeaturesEXT": { + "(VK_EXT_4444_formats)": [ + { + "vuid": "VUID-VkPhysicalDevice4444FormatsFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceSynchronization2FeaturesKHR": { + "(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-VkPhysicalDeviceSynchronization2FeaturesKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR" + } + ] + }, + "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT": { + "(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceFragmentShadingRateFeaturesKHR": { + "(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-VkPhysicalDeviceFragmentShadingRateFeaturesKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR" + } + ] + }, + "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT": { + "(VK_EXT_ycbcr_2plane_444_formats)": [ + { + "vuid": "VUID-VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceColorWriteEnableFeaturesEXT": { + "(VK_EXT_color_write_enable)": [ + { + "vuid": "VUID-VkPhysicalDeviceColorWriteEnableFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT" + } + ] + }, + "VkPhysicalDeviceMultiviewProperties": { + "(VK_VERSION_1_1,VK_KHR_multiview)": [ + { + "vuid": "VUID-VkPhysicalDeviceMultiviewProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES" + } + ] + }, + "VkPhysicalDeviceFloatControlsProperties": { + "(VK_VERSION_1_2,VK_KHR_shader_float_controls)": [ + { + "vuid": "VUID-VkPhysicalDeviceFloatControlsProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES" + } + ] + }, + "VkPhysicalDeviceDiscardRectanglePropertiesEXT": { + "(VK_EXT_discard_rectangles)": [ + { + "vuid": "VUID-VkPhysicalDeviceDiscardRectanglePropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT" + } + ] + }, + "VkPhysicalDeviceSampleLocationsPropertiesEXT": { + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-VkPhysicalDeviceSampleLocationsPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT" + } + ] + }, + "VkPhysicalDeviceExternalMemoryHostPropertiesEXT": { + "(VK_EXT_external_memory_host)": [ + { + "vuid": "VUID-VkPhysicalDeviceExternalMemoryHostPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT" + } + ] + }, + "VkPhysicalDevicePointClippingProperties": { + "(VK_VERSION_1_1,VK_KHR_maintenance2)": [ + { + "vuid": "VUID-VkPhysicalDevicePointClippingProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES" + } + ] + }, + "VkPhysicalDeviceSubgroupProperties": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkPhysicalDeviceSubgroupProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES" + } + ] + }, + "VkPhysicalDeviceSubgroupSizeControlPropertiesEXT": { + "(VK_VERSION_1_1)+(VK_EXT_subgroup_size_control)": [ + { + "vuid": "VUID-VkPhysicalDeviceSubgroupSizeControlPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT" + } + ] + }, + "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT": { + "(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT" + } + ] + }, + "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT": { + "(VK_EXT_vertex_attribute_divisor)": [ + { + "vuid": "VUID-VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT" + } + ] + }, + "VkPhysicalDeviceSamplerFilterMinmaxProperties": { + "(VK_VERSION_1_2,VK_EXT_sampler_filter_minmax)": [ + { + "vuid": "VUID-VkPhysicalDeviceSamplerFilterMinmaxProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES" + } + ] + }, + "VkPhysicalDeviceProtectedMemoryProperties": { + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-VkPhysicalDeviceProtectedMemoryProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES" + } + ] + }, + "VkPhysicalDeviceMaintenance3Properties": { + "(VK_VERSION_1_1,VK_KHR_maintenance3)": [ + { + "vuid": "VUID-VkPhysicalDeviceMaintenance3Properties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES" + } + ] + }, + "VkPhysicalDeviceDescriptorIndexingProperties": { + "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-VkPhysicalDeviceDescriptorIndexingProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES" + } + ] + }, + "VkPhysicalDeviceConservativeRasterizationPropertiesEXT": { + "(VK_EXT_conservative_rasterization)": [ + { + "vuid": "VUID-VkPhysicalDeviceConservativeRasterizationPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT" + } + ] + }, + "VkPhysicalDeviceDepthStencilResolveProperties": { + "(VK_VERSION_1_2,VK_KHR_depth_stencil_resolve)": [ + { + "vuid": "VUID-VkPhysicalDeviceDepthStencilResolveProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES" + } + ] + }, + "VkPhysicalDevicePerformanceQueryPropertiesKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-VkPhysicalDevicePerformanceQueryPropertiesKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR" + } + ] + }, + "VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT": { + "(VK_EXT_texel_buffer_alignment)": [ + { + "vuid": "VUID-VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT" + } + ] + }, + "VkPhysicalDeviceTimelineSemaphoreProperties": { + "(VK_VERSION_1_2,VK_KHR_timeline_semaphore)": [ + { + "vuid": "VUID-VkPhysicalDeviceTimelineSemaphoreProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES" + } + ] + }, + "VkPhysicalDeviceLineRasterizationPropertiesEXT": { + "(VK_EXT_line_rasterization)": [ + { + "vuid": "VUID-VkPhysicalDeviceLineRasterizationPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT" + } + ] + }, + "VkPhysicalDeviceRobustness2PropertiesEXT": { + "(VK_EXT_robustness2)": [ + { + "vuid": "VUID-VkPhysicalDeviceRobustness2PropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT" + } + ] + }, + "VkPhysicalDeviceFragmentShadingRatePropertiesKHR": { + "(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-VkPhysicalDeviceFragmentShadingRatePropertiesKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR" + } + ] + }, + "VkPhysicalDeviceCustomBorderColorPropertiesEXT": { + "(VK_EXT_custom_border_color)": [ + { + "vuid": "VUID-VkPhysicalDeviceCustomBorderColorPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT" + } + ] + }, + "vkGetPhysicalDeviceMultisamplePropertiesEXT": { + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-samples-parameter", + "text": " samples must be a valid VkSampleCountFlagBits value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-pMultisampleProperties-parameter", + "text": " pMultisampleProperties must be a valid pointer to a VkMultisamplePropertiesEXT structure" + } + ] + }, + "VkMultisamplePropertiesEXT": { + "(VK_EXT_sample_locations)": [ + { + "vuid": "VUID-VkMultisamplePropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT" + }, + { + "vuid": "VUID-VkMultisamplePropertiesEXT-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkGetPhysicalDeviceFormatProperties": { + "core": [ + { + "vuid": "VUID-vkGetPhysicalDeviceFormatProperties-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceFormatProperties-format-parameter", + "text": " format must be a valid VkFormat value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceFormatProperties-pFormatProperties-parameter", + "text": " pFormatProperties must be a valid pointer to a VkFormatProperties structure" + } + ] + }, + "vkGetPhysicalDeviceFormatProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceFormatProperties2-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceFormatProperties2-format-parameter", + "text": " format must be a valid VkFormat value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceFormatProperties2-pFormatProperties-parameter", + "text": " pFormatProperties must be a valid pointer to a VkFormatProperties2 structure" + } + ] + }, + "VkFormatProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkFormatProperties2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2" + }, + { + "vuid": "VUID-VkFormatProperties2-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDrmFormatModifierPropertiesList2EXT or VkDrmFormatModifierPropertiesListEXT" + }, + { + "vuid": "VUID-VkFormatProperties2-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + } + ] + }, + "VkDrmFormatModifierPropertiesListEXT": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_EXT_image_drm_format_modifier)": [ + { + "vuid": "VUID-VkDrmFormatModifierPropertiesListEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT" + } + ] + }, + "VkDrmFormatModifierPropertiesList2EXT": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_EXT_image_drm_format_modifier)+(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-VkDrmFormatModifierPropertiesList2EXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT" + } + ] + }, + "vkGetPhysicalDeviceImageFormatProperties": { + "(VK_EXT_image_drm_format_modifier)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-tiling-02248", + "text": " tiling must not be VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT. (Use vkGetPhysicalDeviceImageFormatProperties2 instead)" + } + ], + "core": [ + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-format-parameter", + "text": " format must be a valid VkFormat value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-type-parameter", + "text": " type must be a valid VkImageType value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-tiling-parameter", + "text": " tiling must be a valid VkImageTiling value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-usage-parameter", + "text": " usage must be a valid combination of VkImageUsageFlagBits values" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-usage-requiredbitmask", + "text": " usage must not be 0" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-flags-parameter", + "text": " flags must be a valid combination of VkImageCreateFlagBits values" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties-pImageFormatProperties-parameter", + "text": " pImageFormatProperties must be a valid pointer to a VkImageFormatProperties structure" + } + ] + }, + "vkGetPhysicalDeviceImageFormatProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties2-pNext-01868", + "text": " If the pNext chain of pImageFormatProperties includes a VkAndroidHardwareBufferUsageANDROID structure, the pNext chain of pImageFormatInfo must include a VkPhysicalDeviceExternalImageFormatInfo structure with handleType set to VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID" + } + ], + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties2-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatInfo-parameter", + "text": " pImageFormatInfo must be a valid pointer to a valid VkPhysicalDeviceImageFormatInfo2 structure" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatProperties-parameter", + "text": " pImageFormatProperties must be a valid pointer to a VkImageFormatProperties2 structure" + } + ] + }, + "VkPhysicalDeviceImageFormatInfo2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_EXT_image_drm_format_modifier)": [ + { + "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-tiling-02249", + "text": " tiling must be VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT if and only if the pNext chain includes VkPhysicalDeviceImageDrmFormatModifierInfoEXT" + }, + { + "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-tiling-02313", + "text": " If tiling is VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT and flags contains VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, then the pNext chain must include a VkImageFormatListCreateInfo structure with non-zero viewFormatCount" + } + ], + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2" + }, + { + "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkImageFormatListCreateInfo, VkImageStencilUsageCreateInfo, VkPhysicalDeviceExternalImageFormatInfo, VkPhysicalDeviceImageDrmFormatModifierInfoEXT, or VkPhysicalDeviceImageViewImageFormatInfoEXT" + }, + { + "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-format-parameter", + "text": " format must be a valid VkFormat value" + }, + { + "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-type-parameter", + "text": " type must be a valid VkImageType value" + }, + { + "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-tiling-parameter", + "text": " tiling must be a valid VkImageTiling value" + }, + { + "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-usage-parameter", + "text": " usage must be a valid combination of VkImageUsageFlagBits values" + }, + { + "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-usage-requiredbitmask", + "text": " usage must not be 0" + }, + { + "vuid": "VUID-VkPhysicalDeviceImageFormatInfo2-flags-parameter", + "text": " flags must be a valid combination of VkImageCreateFlagBits values" + } + ] + }, + "VkImageFormatProperties2": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)": [ + { + "vuid": "VUID-VkImageFormatProperties2-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2" + }, + { + "vuid": "VUID-VkImageFormatProperties2-pNext-pNext", + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkExternalImageFormatProperties, VkFilterCubicImageViewImageFormatPropertiesEXT, or VkSamplerYcbcrConversionImageFormatProperties" + }, + { + "vuid": "VUID-VkImageFormatProperties2-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + } + ] + }, + "VkPhysicalDeviceExternalImageFormatInfo": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)": [ + { + "vuid": "VUID-VkPhysicalDeviceExternalImageFormatInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO" + }, + { + "vuid": "VUID-VkPhysicalDeviceExternalImageFormatInfo-handleType-parameter", + "text": " If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" + } + ] + }, + "VkExternalImageFormatProperties": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)": [ + { + "vuid": "VUID-VkExternalImageFormatProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES" + } + ] + }, + "VkPhysicalDeviceImageDrmFormatModifierInfoEXT": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_EXT_image_drm_format_modifier)": [ + { + "vuid": "VUID-VkPhysicalDeviceImageDrmFormatModifierInfoEXT-sharingMode-02314", + "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, then pQueueFamilyIndices must be a valid pointer to an array of queueFamilyIndexCount uint32_t values" + }, + { + "vuid": "VUID-VkPhysicalDeviceImageDrmFormatModifierInfoEXT-sharingMode-02315", + "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, then queueFamilyIndexCount must be greater than 1" + }, + { + "vuid": "VUID-VkPhysicalDeviceImageDrmFormatModifierInfoEXT-sharingMode-02316", + "text": " If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than the pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties2 for the physicalDevice that was used to create device" + }, + { + "vuid": "VUID-VkPhysicalDeviceImageDrmFormatModifierInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT" + }, + { + "vuid": "VUID-VkPhysicalDeviceImageDrmFormatModifierInfoEXT-sharingMode-parameter", + "text": " sharingMode must be a valid VkSharingMode value" + } + ] + }, + "VkSamplerYcbcrConversionImageFormatProperties": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + { + "vuid": "VUID-VkSamplerYcbcrConversionImageFormatProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES" + } + ] + }, + "VkPhysicalDeviceImageViewImageFormatInfoEXT": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-VkPhysicalDeviceImageViewImageFormatInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT" + }, + { + "vuid": "VUID-VkPhysicalDeviceImageViewImageFormatInfoEXT-imageViewType-parameter", + "text": " imageViewType must be a valid VkImageViewType value" + } + ] + }, + "VkFilterCubicImageViewImageFormatPropertiesEXT": { + "(VK_VERSION_1_1,VK_KHR_get_physical_device_properties2)+(VK_EXT_filter_cubic)": [ + { + "vuid": "VUID-VkFilterCubicImageViewImageFormatPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT" + }, + { + "vuid": "VUID-VkFilterCubicImageViewImageFormatPropertiesEXT-pNext-02627", + "text": " If the pNext chain of the VkImageFormatProperties2 structure includes a VkFilterCubicImageViewImageFormatPropertiesEXT structure, the pNext chain of the VkPhysicalDeviceImageFormatInfo2 structure must include a VkPhysicalDeviceImageViewImageFormatInfoEXT structure with an imageViewType that is compatible with imageType" + } + ] + }, + "vkGetPhysicalDeviceExternalBufferProperties": { + "(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceExternalBufferProperties-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceExternalBufferProperties-pExternalBufferInfo-parameter", + "text": " pExternalBufferInfo must be a valid pointer to a valid VkPhysicalDeviceExternalBufferInfo structure" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceExternalBufferProperties-pExternalBufferProperties-parameter", + "text": " pExternalBufferProperties must be a valid pointer to a VkExternalBufferProperties structure" + } + ] + }, + "VkPhysicalDeviceExternalBufferInfo": { + "(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)": [ + { + "vuid": "VUID-VkPhysicalDeviceExternalBufferInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO" + }, + { + "vuid": "VUID-VkPhysicalDeviceExternalBufferInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkPhysicalDeviceExternalBufferInfo-flags-parameter", + "text": " flags must be a valid combination of VkBufferCreateFlagBits values" + }, + { + "vuid": "VUID-VkPhysicalDeviceExternalBufferInfo-usage-parameter", + "text": " usage must be a valid combination of VkBufferUsageFlagBits values" + }, + { + "vuid": "VUID-VkPhysicalDeviceExternalBufferInfo-usage-requiredbitmask", + "text": " usage must not be 0" + }, + { + "vuid": "VUID-VkPhysicalDeviceExternalBufferInfo-handleType-parameter", + "text": " handleType must be a valid VkExternalMemoryHandleTypeFlagBits value" + } + ] + }, + "VkExternalBufferProperties": { + "(VK_VERSION_1_1,VK_KHR_external_memory_capabilities)": [ + { + "vuid": "VUID-VkExternalBufferProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES" + }, + { + "vuid": "VUID-VkExternalBufferProperties-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkGetPhysicalDeviceExternalSemaphoreProperties": { + "(VK_VERSION_1_1,VK_KHR_external_semaphore_capabilities)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-pExternalSemaphoreInfo-parameter", + "text": " pExternalSemaphoreInfo must be a valid pointer to a valid VkPhysicalDeviceExternalSemaphoreInfo structure" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-pExternalSemaphoreProperties-parameter", + "text": " pExternalSemaphoreProperties must be a valid pointer to a VkExternalSemaphoreProperties structure" + } + ] + }, + "VkPhysicalDeviceExternalSemaphoreInfo": { + "(VK_VERSION_1_1,VK_KHR_external_semaphore_capabilities)": [ + { + "vuid": "VUID-VkPhysicalDeviceExternalSemaphoreInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO" + }, + { + "vuid": "VUID-VkPhysicalDeviceExternalSemaphoreInfo-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkSemaphoreTypeCreateInfo" + }, + { + "vuid": "VUID-VkPhysicalDeviceExternalSemaphoreInfo-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkPhysicalDeviceExternalSemaphoreInfo-handleType-parameter", + "text": " handleType must be a valid VkExternalSemaphoreHandleTypeFlagBits value" + } + ] + }, + "VkExternalSemaphoreProperties": { + "(VK_VERSION_1_1,VK_KHR_external_semaphore_capabilities)": [ + { + "vuid": "VUID-VkExternalSemaphoreProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES" + }, + { + "vuid": "VUID-VkExternalSemaphoreProperties-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkGetPhysicalDeviceExternalFenceProperties": { + "(VK_VERSION_1_1,VK_KHR_external_fence_capabilities)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceExternalFenceProperties-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceExternalFenceProperties-pExternalFenceInfo-parameter", + "text": " pExternalFenceInfo must be a valid pointer to a valid VkPhysicalDeviceExternalFenceInfo structure" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceExternalFenceProperties-pExternalFenceProperties-parameter", + "text": " pExternalFenceProperties must be a valid pointer to a VkExternalFenceProperties structure" + } + ] + }, + "VkPhysicalDeviceExternalFenceInfo": { + "(VK_VERSION_1_1,VK_KHR_external_fence_capabilities)": [ + { + "vuid": "VUID-VkPhysicalDeviceExternalFenceInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO" + }, + { + "vuid": "VUID-VkPhysicalDeviceExternalFenceInfo-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkPhysicalDeviceExternalFenceInfo-handleType-parameter", + "text": " handleType must be a valid VkExternalFenceHandleTypeFlagBits value" + } + ] + }, + "VkExternalFenceProperties": { + "(VK_VERSION_1_1,VK_KHR_external_fence_capabilities)": [ + { + "vuid": "VUID-VkExternalFenceProperties-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES" + }, + { + "vuid": "VUID-VkExternalFenceProperties-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT": { + "(VK_EXT_calibrated_timestamps)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceCalibrateableTimeDomainsEXT-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceCalibrateableTimeDomainsEXT-pTimeDomainCount-parameter", + "text": " pTimeDomainCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceCalibrateableTimeDomainsEXT-pTimeDomains-parameter", + "text": " If the value referenced by pTimeDomainCount is not 0, and pTimeDomains is not NULL, pTimeDomains must be a valid pointer to an array of pTimeDomainCount VkTimeDomainEXT values" + } + ] + }, + "vkGetPhysicalDeviceRefreshableObjectTypesKHR": { + "(VK_KHR_object_refresh)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceRefreshableObjectTypesKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceRefreshableObjectTypesKHR-pRefreshableObjectTypeCount-parameter", + "text": " pRefreshableObjectTypeCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceRefreshableObjectTypesKHR-pRefreshableObjectTypes-parameter", + "text": " If the value referenced by pRefreshableObjectTypeCount is not 0, and pRefreshableObjectTypes is not NULL, pRefreshableObjectTypes must be a valid pointer to an array of pRefreshableObjectTypeCount VkObjectType values" + } + ] + }, + "vkSetDebugUtilsObjectNameEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkSetDebugUtilsObjectNameEXT-pNameInfo-02587", + "text": " pNameInfo->objectType must not be VK_OBJECT_TYPE_UNKNOWN" + }, + { + "vuid": "VUID-vkSetDebugUtilsObjectNameEXT-pNameInfo-02588", + "text": " pNameInfo->objectHandle must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkSetDebugUtilsObjectNameEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkSetDebugUtilsObjectNameEXT-pNameInfo-parameter", + "text": " pNameInfo must be a valid pointer to a valid VkDebugUtilsObjectNameInfoEXT structure" + } + ] + }, + "VkDebugUtilsObjectNameInfoEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-VkDebugUtilsObjectNameInfoEXT-objectType-02589", + "text": " If objectType is VK_OBJECT_TYPE_UNKNOWN, objectHandle must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkDebugUtilsObjectNameInfoEXT-objectType-02590", + "text": " If objectType is not VK_OBJECT_TYPE_UNKNOWN, objectHandle must be VK_NULL_HANDLE or a valid Vulkan handle of the type associated with objectType as defined in the VkObjectType and Vulkan Handle Relationship table" + }, + { + "vuid": "VUID-VkDebugUtilsObjectNameInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT" + }, + { + "vuid": "VUID-VkDebugUtilsObjectNameInfoEXT-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDebugUtilsObjectNameInfoEXT-objectType-parameter", + "text": " objectType must be a valid VkObjectType value" + }, + { + "vuid": "VUID-VkDebugUtilsObjectNameInfoEXT-pObjectName-parameter", + "text": " If pObjectName is not NULL, pObjectName must be a null-terminated UTF-8 string" + } + ] + }, + "vkSetDebugUtilsObjectTagEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkSetDebugUtilsObjectTagEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkSetDebugUtilsObjectTagEXT-pTagInfo-parameter", + "text": " pTagInfo must be a valid pointer to a valid VkDebugUtilsObjectTagInfoEXT structure" + } + ] + }, + "VkDebugUtilsObjectTagInfoEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-objectType-01908", + "text": " objectType must not be VK_OBJECT_TYPE_UNKNOWN" + }, + { + "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-objectHandle-01910", + "text": " objectHandle must be a valid Vulkan handle of the type associated with objectType as defined in the VkObjectType and Vulkan Handle Relationship table" + }, + { + "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT" + }, + { + "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-objectType-parameter", + "text": " objectType must be a valid VkObjectType value" + }, + { + "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-pTag-parameter", + "text": " pTag must be a valid pointer to an array of tagSize bytes" + }, + { + "vuid": "VUID-VkDebugUtilsObjectTagInfoEXT-tagSize-arraylength", + "text": " tagSize must be greater than 0" + } + ] + }, + "vkQueueBeginDebugUtilsLabelEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkQueueBeginDebugUtilsLabelEXT-queue-parameter", + "text": " queue must be a valid VkQueue handle" + }, + { + "vuid": "VUID-vkQueueBeginDebugUtilsLabelEXT-pLabelInfo-parameter", + "text": " pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure" + } + ] + }, + "VkDebugUtilsLabelEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-VkDebugUtilsLabelEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT" + }, + { + "vuid": "VUID-VkDebugUtilsLabelEXT-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDebugUtilsLabelEXT-pLabelName-parameter", + "text": " pLabelName must be a null-terminated UTF-8 string" + } + ] + }, + "vkQueueEndDebugUtilsLabelEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkQueueEndDebugUtilsLabelEXT-None-01911", + "text": " There must be an outstanding vkQueueBeginDebugUtilsLabelEXT command prior to the vkQueueEndDebugUtilsLabelEXT on the queue" + }, + { + "vuid": "VUID-vkQueueEndDebugUtilsLabelEXT-queue-parameter", + "text": " queue must be a valid VkQueue handle" + } + ] + }, + "vkQueueInsertDebugUtilsLabelEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkQueueInsertDebugUtilsLabelEXT-queue-parameter", + "text": " queue must be a valid VkQueue handle" + }, + { + "vuid": "VUID-vkQueueInsertDebugUtilsLabelEXT-pLabelInfo-parameter", + "text": " pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure" + } + ] + }, + "vkCmdBeginDebugUtilsLabelEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdBeginDebugUtilsLabelEXT-pLabelInfo-parameter", + "text": " pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure" + }, + { + "vuid": "VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + } + ] + }, + "vkCmdEndDebugUtilsLabelEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-01912", + "text": " There must be an outstanding vkCmdBeginDebugUtilsLabelEXT command prior to the vkCmdEndDebugUtilsLabelEXT on the queue that commandBuffer is submitted to" + }, + { + "vuid": "VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-01913", + "text": " If commandBuffer is a secondary command buffer, there must be an outstanding vkCmdBeginDebugUtilsLabelEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdEndDebugUtilsLabelEXT" + }, + { + "vuid": "VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + } + ] + }, + "vkCmdInsertDebugUtilsLabelEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdInsertDebugUtilsLabelEXT-pLabelInfo-parameter", + "text": " pLabelInfo must be a valid pointer to a valid VkDebugUtilsLabelEXT structure" + }, + { + "vuid": "VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + } + ] + }, + "vkCreateDebugUtilsMessengerEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkCreateDebugUtilsMessengerEXT-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkCreateDebugUtilsMessengerEXT-pCreateInfo-parameter", + "text": " pCreateInfo must be a valid pointer to a valid VkDebugUtilsMessengerCreateInfoEXT structure" + }, + { + "vuid": "VUID-vkCreateDebugUtilsMessengerEXT-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkCreateDebugUtilsMessengerEXT-pMessenger-parameter", + "text": " pMessenger must be a valid pointer to a VkDebugUtilsMessengerEXT handle" + } + ] + }, + "VkDebugUtilsMessengerCreateInfoEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-pfnUserCallback-01914", + "text": " pfnUserCallback must be a valid PFN_vkDebugUtilsMessengerCallbackEXT" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-parameter", + "text": " messageSeverity must be a valid combination of VkDebugUtilsMessageSeverityFlagBitsEXT values" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-requiredbitmask", + "text": " messageSeverity must not be 0" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-parameter", + "text": " messageType must be a valid combination of VkDebugUtilsMessageTypeFlagBitsEXT values" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-requiredbitmask", + "text": " messageType must not be 0" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCreateInfoEXT-pfnUserCallback-parameter", + "text": " pfnUserCallback must be a valid PFN_vkDebugUtilsMessengerCallbackEXT value" + } + ] + }, + "PFN_vkDebugUtilsMessengerCallbackEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-PFN_vkDebugUtilsMessengerCallbackEXT-None-04769", + "text": " The callback must not make calls to any Vulkan commands" + } + ] + }, + "VkDebugUtilsMessengerCallbackDataEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-VkDebugUtilsMessengerCallbackDataEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCallbackDataEXT-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCallbackDataEXT-flags-zerobitmask", + "text": " flags must be 0" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCallbackDataEXT-pMessageIdName-parameter", + "text": " If pMessageIdName is not NULL, pMessageIdName must be a null-terminated UTF-8 string" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCallbackDataEXT-pMessage-parameter", + "text": " pMessage must be a null-terminated UTF-8 string" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCallbackDataEXT-pQueueLabels-parameter", + "text": " If queueLabelCount is not 0, pQueueLabels must be a valid pointer to an array of queueLabelCount valid VkDebugUtilsLabelEXT structures" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCallbackDataEXT-pCmdBufLabels-parameter", + "text": " If cmdBufLabelCount is not 0, pCmdBufLabels must be a valid pointer to an array of cmdBufLabelCount valid VkDebugUtilsLabelEXT structures" + }, + { + "vuid": "VUID-VkDebugUtilsMessengerCallbackDataEXT-pObjects-parameter", + "text": " If objectCount is not 0, pObjects must be a valid pointer to an array of objectCount valid VkDebugUtilsObjectNameInfoEXT structures" + } + ] + }, + "vkSubmitDebugUtilsMessageEXT": { + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkSubmitDebugUtilsMessageEXT-objectType-02591", + "text": " The objectType member of each element of pCallbackData->pObjects must not be VK_OBJECT_TYPE_UNKNOWN" + }, + { + "vuid": "VUID-vkSubmitDebugUtilsMessageEXT-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkSubmitDebugUtilsMessageEXT-messageSeverity-parameter", + "text": " messageSeverity must be a valid VkDebugUtilsMessageSeverityFlagBitsEXT value" + }, + { + "vuid": "VUID-vkSubmitDebugUtilsMessageEXT-messageTypes-parameter", + "text": " messageTypes must be a valid combination of VkDebugUtilsMessageTypeFlagBitsEXT values" + }, + { + "vuid": "VUID-vkSubmitDebugUtilsMessageEXT-messageTypes-requiredbitmask", + "text": " messageTypes must not be 0" + }, + { + "vuid": "VUID-vkSubmitDebugUtilsMessageEXT-pCallbackData-parameter", + "text": " pCallbackData must be a valid pointer to a valid VkDebugUtilsMessengerCallbackDataEXT structure" + } + ] + }, + "vkDestroyDebugUtilsMessengerEXT": { + "(VK_EXT_debug_utils)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01915", + "text": " If VkAllocationCallbacks were provided when messenger was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01916", + "text": " If no VkAllocationCallbacks were provided when messenger was created, pAllocator must be NULL" + } + ], + "(VK_EXT_debug_utils)": [ + { + "vuid": "VUID-vkDestroyDebugUtilsMessengerEXT-instance-parameter", + "text": " instance must be a valid VkInstance handle" + }, + { + "vuid": "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parameter", + "text": " If messenger is not VK_NULL_HANDLE, messenger must be a valid VkDebugUtilsMessengerEXT handle" + }, + { + "vuid": "VUID-vkDestroyDebugUtilsMessengerEXT-pAllocator-null", + "text": " pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parent", + "text": " If messenger is a valid handle, it must have been created, allocated, or retrieved from instance" + } + ] + }, + "VkDebugMarkerObjectNameInfoEXT": { + "(VK_EXT_debug_marker)": [ + { + "vuid": "VUID-VkDebugMarkerObjectNameInfoEXT-objectType-01490", + "text": " objectType must not be VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT" + }, + { + "vuid": "VUID-VkDebugMarkerObjectNameInfoEXT-object-01491", + "text": " object must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkDebugMarkerObjectNameInfoEXT-object-01492", + "text": " object must be a Vulkan object of the type associated with objectType as defined in VkDebugReportObjectTypeEXT and Vulkan Handle Relationship" + } + ] + }, + "VkDebugMarkerObjectTagInfoEXT": { + "(VK_EXT_debug_marker)": [ + { + "vuid": "VUID-VkDebugMarkerObjectTagInfoEXT-objectType-01493", + "text": " objectType must not be VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT" + }, + { + "vuid": "VUID-VkDebugMarkerObjectTagInfoEXT-object-01494", + "text": " object must not be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-VkDebugMarkerObjectTagInfoEXT-object-01495", + "text": " object must be a Vulkan object of the type associated with objectType as defined in VkDebugReportObjectTypeEXT and Vulkan Handle Relationship" + } + ] + }, + "vkCmdDebugMarkerEndEXT": { + "(VK_EXT_debug_marker)": [ + { + "vuid": "VUID-vkCmdDebugMarkerEndEXT-commandBuffer-01239", + "text": " There must be an outstanding vkCmdDebugMarkerBeginEXT command prior to the vkCmdDebugMarkerEndEXT on the queue that commandBuffer is submitted to" + }, + { + "vuid": "VUID-vkCmdDebugMarkerEndEXT-commandBuffer-01240", + "text": " If commandBuffer is a secondary command buffer, there must be an outstanding vkCmdDebugMarkerBeginEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdDebugMarkerEndEXT" + } + ] + }, + "vkDebugReportMessageEXT": { + "(VK_EXT_debug_report)": [ + { + "vuid": "VUID-vkDebugReportMessageEXT-object-01241", + "text": " object must be a Vulkan object or VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkDebugReportMessageEXT-objectType-01498", + "text": " If objectType is not VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT and object is not VK_NULL_HANDLE, object must be a Vulkan object of the corresponding type associated with objectType as defined in VkDebugReportObjectTypeEXT and Vulkan Handle Relationship" + } + ] + }, + "vkDestroyDebugReportCallbackEXT": { + "(VK_EXT_debug_report)+!(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkDestroyDebugReportCallbackEXT-instance-01242", + "text": " If VkAllocationCallbacks were provided when callback was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyDebugReportCallbackEXT-instance-01243", + "text": " If no VkAllocationCallbacks were provided when callback was created, pAllocator must be NULL" + } + ] + }, + "vkGetQueueCheckpointData2NV": { + "(VK_NV_device_diagnostic_checkpoints)+(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-vkGetQueueCheckpointData2NV-queue-03892", + "text": " The device that queue belongs to must be in the lost state" + }, + { + "vuid": "VUID-vkGetQueueCheckpointData2NV-queue-parameter", + "text": " queue must be a valid VkQueue handle" + }, + { + "vuid": "VUID-vkGetQueueCheckpointData2NV-pCheckpointDataCount-parameter", + "text": " pCheckpointDataCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetQueueCheckpointData2NV-pCheckpointData-parameter", + "text": " If the value referenced by pCheckpointDataCount is not 0, and pCheckpointData is not NULL, pCheckpointData must be a valid pointer to an array of pCheckpointDataCount VkCheckpointData2NV structures" + } + ] + }, + "VkCheckpointData2NV": { + "(VK_NV_device_diagnostic_checkpoints)+(VK_KHR_synchronization2)": [ + { + "vuid": "VUID-VkCheckpointData2NV-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV" + }, + { + "vuid": "VUID-VkCheckpointData2NV-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "vkGetQueueCheckpointDataNV": { + "(VK_NV_device_diagnostic_checkpoints)": [ + { + "vuid": "VUID-vkGetQueueCheckpointDataNV-queue-02025", + "text": " The device that queue belongs to must be in the lost state" + } + ] + }, + "VkFaultData": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkFaultData-pNext-05019", + "text": " pNext must be NULL or a valid host pointer to an implementation-specific amount of writeable memory." + }, + { + "vuid": "VUID-VkFaultData-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_FAULT_DATA" + }, + { + "vuid": "VUID-VkFaultData-faultLevel-parameter", + "text": " faultLevel must be a valid VkFaultLevel value" + }, + { + "vuid": "VUID-VkFaultData-faultType-parameter", + "text": " faultType must be a valid VkFaultType value" + } + ] + }, + "vkGetFaultData": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-vkGetFaultData-pFaultCount-05020", + "text": " pFaultCount must be less than or equal to maxQueryFaultCount" + }, + { + "vuid": "VUID-vkGetFaultData-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetFaultData-faultQueryBehavior-parameter", + "text": " faultQueryBehavior must be a valid VkFaultQueryBehavior value" + }, + { + "vuid": "VUID-vkGetFaultData-pUnrecordedFaults-parameter", + "text": " pUnrecordedFaults must be a valid pointer to a VkBool32 value" + }, + { + "vuid": "VUID-vkGetFaultData-pFaultCount-parameter", + "text": " pFaultCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkGetFaultData-pFaults-parameter", + "text": " If pFaults is not NULL, pFaults must be a valid pointer to an array of pFaultCount VkFaultData structures" + }, + { + "vuid": "VUID-vkGetFaultData-pFaultCount-arraylength", + "text": " If pFaults is not NULL, the value referenced by pFaultCount must be greater than 0" + } + ] + }, + "VkFaultCallbackInfo": { + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-VkFaultCallbackInfo-faultCount-05088", + "text": " faultCount must be equal to VkPhysicalDeviceVulkanSC10Properties::maxCallbackFaultCount" + }, + { + "vuid": "VUID-VkFaultCallbackInfo-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO" + }, + { + "vuid": "VUID-VkFaultCallbackInfo-pFaults-parameter", + "text": " pFaults must be a valid pointer to an array of faultCount VkFaultData structures" + }, + { + "vuid": "VUID-VkFaultCallbackInfo-pfnFaultCallback-parameter", + "text": " pfnFaultCallback must be a valid PFN_vkFaultCallbackFunction value" + }, + { + "vuid": "VUID-VkFaultCallbackInfo-faultCount-arraylength", + "text": " faultCount must be greater than 0" + } + ] + }, + "StandaloneSpirv": { + "core": [ + { + "vuid": "VUID-StandaloneSpirv-None-04633", + "text": " Every entry point must have no return value and accept no arguments" + }, + { + "vuid": "VUID-StandaloneSpirv-None-04634", + "text": " The static function-call graph for an entry point must not contain cycles; that is, static recursion is not allowed" + }, + { + "vuid": "VUID-StandaloneSpirv-None-04635", + "text": " The Logical or PhysicalStorageBuffer64 addressing model must be selected" + }, + { + "vuid": "VUID-StandaloneSpirv-None-04636", + "text": " Scope for execution must be limited to Workgroup or Subgroup" + }, + { + "vuid": "VUID-StandaloneSpirv-None-04637", + "text": " If the Scope for execution is Workgroup, then it must only be used in the task, mesh, tessellation control, or compute execution models" + }, + { + "vuid": "VUID-StandaloneSpirv-None-04638", + "text": " Scope for memory must be limited to Device, QueueFamily, Workgroup, ShaderCallKHR, Subgroup, or Invocation" + }, + { + "vuid": "VUID-StandaloneSpirv-None-04639", + "text": " If the Scope for memory is Workgroup, then it must only be used in the task, mesh, or compute execution models" + }, + { + "vuid": "VUID-StandaloneSpirv-None-04640", + "text": " If the Scope for memory is ShaderCallKHR, then it must only be used in ray generation, intersection, closest hit, any-hit, miss, and callable execution models" + }, + { + "vuid": "VUID-StandaloneSpirv-None-04641", + "text": " If the Scope for memory is Invocation, then memory semantics must be None" + }, + { + "vuid": "VUID-StandaloneSpirv-None-04643", + "text": " Storage Class must be limited to UniformConstant, Input, Uniform, Output, Workgroup, Private, Function, PushConstant, Image, StorageBuffer, RayPayloadKHR, IncomingRayPayloadKHR, HitAttributeKHR, CallableDataKHR, IncomingCallableDataKHR, ShaderRecordBufferKHR, or PhysicalStorageBuffer" + }, + { + "vuid": "VUID-StandaloneSpirv-None-04644", + "text": " If the Storage Class is Output, then it must not be used in the GlCompute, RayGenerationKHR, IntersectionKHR, AnyHitKHR, ClosestHitKHR, MissKHR, or CallableKHR execution models" + }, + { + "vuid": "VUID-StandaloneSpirv-None-04645", + "text": " If the Storage Class is Workgroup, then it must only be used in the task, mesh, or compute execution models" + }, + { + "vuid": "VUID-StandaloneSpirv-OpAtomicStore-04730", + "text": " OpAtomicStore must not use Acquire, AcquireRelease, or SequentiallyConsistent memory semantics" + }, + { + "vuid": "VUID-StandaloneSpirv-OpAtomicLoad-04731", + "text": " OpAtomicLoad must not use Release, AcquireRelease, or SequentiallyConsistent memory semantics" + }, + { + "vuid": "VUID-StandaloneSpirv-OpMemoryBarrier-04732", + "text": " OpMemoryBarrier must use one of Acquire, Release, AcquireRelease, or SequentiallyConsistent memory semantics" + }, + { + "vuid": "VUID-StandaloneSpirv-OpMemoryBarrier-04733", + "text": " OpMemoryBarrier must include at least one storage class" + }, + { + "vuid": "VUID-StandaloneSpirv-OpControlBarrier-04650", + "text": " If the semantics for OpControlBarrier includes one of Acquire, Release, AcquireRelease, or SequentiallyConsistent memory semantics, then it must include at least one storage class" + }, + { + "vuid": "VUID-StandaloneSpirv-OpVariable-04651", + "text": " Any OpVariable with an Initializer operand must have Output, Private, Function, or Workgroup as its Storage Class operand" + }, + { + "vuid": "VUID-StandaloneSpirv-OpVariable-04734", + "text": " Any OpVariable with an Initializer operand and Workgroup as its Storage Class operand must use OpConstantNull as the initializer" + }, + { + "vuid": "VUID-StandaloneSpirv-OpReadClockKHR-04652", + "text": " Scope for OpReadClockKHR must be limited to Subgroup or Device" + }, + { + "vuid": "VUID-StandaloneSpirv-OriginLowerLeft-04653", + "text": " The OriginLowerLeft execution mode must not be used; fragment entry points must declare OriginUpperLeft" + }, + { + "vuid": "VUID-StandaloneSpirv-PixelCenterInteger-04654", + "text": " The PixelCenterInteger execution mode must not be used (pixels are always centered at half-integer coordinates)" + }, + { + "vuid": "VUID-StandaloneSpirv-UniformConstant-04655", + "text": " Any variable in the UniformConstant storage class must be typed as either OpTypeImage, OpTypeSampler, OpTypeSampledImage, OpTypeAccelerationStructureKHR, or an array of one of these types" + }, + { + "vuid": "VUID-StandaloneSpirv-OpTypeImage-04656", + "text": " OpTypeImage must declare a scalar 32-bit float, 64-bit integer, or 32-bit integer type for the “Sampled Type” (RelaxedPrecision can be applied to a sampling instruction and to the variable holding the result of a sampling instruction)" + }, + { + "vuid": "VUID-StandaloneSpirv-OpTypeImage-04657", + "text": " OpTypeImage must have a “Sampled” operand of 1 (sampled image) or 2 (storage image)" + }, + { + "vuid": "VUID-StandaloneSpirv-Image-04965", + "text": " The converted bit width, signedness, and numeric type of the Image Format operand of an OpTypeImage must match the Sampled Type, as defined in Image Format and Type Matching" + }, + { + "vuid": "VUID-StandaloneSpirv-OpImageTexelPointer-04658", + "text": " If an OpImageTexelPointer is used in an atomic operation, the image type of the image parameter to OpImageTexelPointer must have an image format of R64i, R64ui, R32f, R32i, or R32ui" + }, + { + "vuid": "VUID-StandaloneSpirv-OpImageQuerySizeLod-04659", + "text": " OpImageQuerySizeLod, OpImageQueryLod, and OpImageQueryLevels must only consume an “Image” operand whose type has its “Sampled” operand set to 1" + }, + { + "vuid": "VUID-StandaloneSpirv-OpTypeImage-06214", + "text": " An OpTypeImage with a “Dim” operand of SubpassData must have an “Arrayed” operand of 0 (non-arrayed) and a “Sampled” operand of 2 (storage image)" + }, + { + "vuid": "VUID-StandaloneSpirv-SubpassData-04660", + "text": " The (u,v) coordinates used for a SubpassData must be the <id> of a constant vector (0,0), or if a layer coordinate is used, must be a vector that was formed with constant 0 for the u and v components" + }, + { + "vuid": "VUID-StandaloneSpirv-OpTypeImage-04661", + "text": " Objects of types OpTypeImage, OpTypeSampler, OpTypeSampledImage, and arrays of these types must not be stored to or modified" + }, + { + "vuid": "VUID-StandaloneSpirv-Offset-04662", + "text": " Any image operation must use at most one of the Offset, ConstOffset, and ConstOffsets image operands" + }, + { + "vuid": "VUID-StandaloneSpirv-Offset-04663", + "text": " Image operand Offset must only be used with OpImage*Gather instructions" + }, + { + "vuid": "VUID-StandaloneSpirv-Offset-04865", + "text": " Any image instruction which uses an Offset, ConstOffset, or ConstOffsets image operand, must only consume a “Sampled Image” operand whose type has its “Sampled” operand set to 1" + }, + { + "vuid": "VUID-StandaloneSpirv-OpImageGather-04664", + "text": " The “Component” operand of OpImageGather, and OpImageSparseGather must be the <id> of a constant instruction" + }, + { + "vuid": "VUID-StandaloneSpirv-OpImage-04777", + "text": " OpImage*Dref must not consume an image whose Dim is 3D" + }, + { + "vuid": "VUID-StandaloneSpirv-OpTypeAccelerationStructureKHR-04665", + "text": " Objects of types OpTypeAccelerationStructureKHR and arrays of this type must not be stored to or modified" + }, + { + "vuid": "VUID-StandaloneSpirv-OpReportIntersectionKHR-04666", + "text": " The value of the “Hit Kind” operand of OpReportIntersectionKHR must be in the range [0,127]" + }, + { + "vuid": "VUID-StandaloneSpirv-None-04667", + "text": " Structure types must not contain opaque types" + }, + { + "vuid": "VUID-StandaloneSpirv-BuiltIn-04668", + "text": " Any BuiltIn decoration not listed in Built-In Variables must not be used" + }, + { + "vuid": "VUID-StandaloneSpirv-Location-04915", + "text": " The Location or Component decorations must not be used with BuiltIn" + }, + { + "vuid": "VUID-StandaloneSpirv-Location-04916", + "text": " The Location decorations must be used on user-defined variables" + }, + { + "vuid": "VUID-StandaloneSpirv-Location-04917", + "text": " The Location decorations must be used on an OpVariable with a structure type that is not a block" + }, + { + "vuid": "VUID-StandaloneSpirv-Location-04918", + "text": " The Location decorations must not be used on the members of OpVariable with a structure type that is decorated with Location" + }, + { + "vuid": "VUID-StandaloneSpirv-Location-04919", + "text": " The Location decorations must be used on each member of OpVariable with a structure type that is a block not decorated with Location" + }, + { + "vuid": "VUID-StandaloneSpirv-Component-04920", + "text": " The Component decoration value must not be greater than 3" + }, + { + "vuid": "VUID-StandaloneSpirv-Component-04921", + "text": " If the Component decoration is used on an OpVariable that has a OpTypeVector type with a Component Type with a Width that is less than or equal to 32, the sum of its Component Count and the Component decoration value must be less than 4" + }, + { + "vuid": "VUID-StandaloneSpirv-Component-04922", + "text": " If the Component decoration is used on an OpVariable that has a OpTypeVector type with a Component Type with a Width that is equal to 64, the sum of two times its Component Count and the Component decoration value must be less than 4" + }, + { + "vuid": "VUID-StandaloneSpirv-Component-04923", + "text": " The Component decorations value must not be 1 or 3 for scalar or two-component 64-bit data types" + }, + { + "vuid": "VUID-StandaloneSpirv-Component-04924", + "text": " The Component decorations must not used with any type that is not a scalar or vector" + }, + { + "vuid": "VUID-StandaloneSpirv-GLSLShared-04669", + "text": " The GLSLShared and GLSLPacked decorations must not be used" + }, + { + "vuid": "VUID-StandaloneSpirv-Flat-04670", + "text": " The Flat, NoPerspective, Sample, and Centroid decorations must only be used on variables with the Output or Input storage class" + }, + { + "vuid": "VUID-StandaloneSpirv-Flat-06201", + "text": " The Flat, NoPerspective, Sample, and Centroid decorations must not be used on variables with the Output storage class in a fragment shader" + }, + { + "vuid": "VUID-StandaloneSpirv-Flat-06202", + "text": " The Flat, NoPerspective, Sample, and Centroid decorations must not be used on variables with the Input storage class in a vertex shader" + }, + { + "vuid": "VUID-StandaloneSpirv-Flat-04744", + "text": " Any variable with integer or double-precision floating-point type and with Input storage class in a fragment shader, must be decorated Flat" + }, + { + "vuid": "VUID-StandaloneSpirv-ViewportRelativeNV-04672", + "text": " The ViewportRelativeNV decoration must only be used on a variable decorated with Layer in the vertex, tessellation evaluation, or geometry shader stages" + }, + { + "vuid": "VUID-StandaloneSpirv-ViewportRelativeNV-04673", + "text": " The ViewportRelativeNV decoration must not be used unless a variable decorated with one of ViewportIndex or ViewportMaskNV is also statically used by the same OpEntryPoint" + }, + { + "vuid": "VUID-StandaloneSpirv-ViewportMaskNV-04674", + "text": " The ViewportMaskNV and ViewportIndex decorations must not both be statically used by one or more OpEntryPoint’s that form the pre-rasterization shader stages of a graphics pipeline" + }, + { + "vuid": "VUID-StandaloneSpirv-FPRoundingMode-04675", + "text": " Rounding modes other than round-to-nearest-even and round-towards-zero must not be used for the FPRoundingMode decoration" + }, + { + "vuid": "VUID-StandaloneSpirv-FPRoundingMode-04676", + "text": " The FPRoundingMode decoration must only be used for a width-only conversion instruction whose only uses are Object operands of OpStore instructions storing through a pointer to a 16-bit floating-point object in the StorageBuffer, PhysicalStorageBuffer, Uniform, or Output storage class" + }, + { + "vuid": "VUID-StandaloneSpirv-Invariant-04677", + "text": " Variables decorated with Invariant and variables with structure types that have any members decorated with Invariant must be in the Output or Input storage class, Invariant used on an Input storage class variable or structure member has no effect" + }, + { + "vuid": "VUID-StandaloneSpirv-VulkanMemoryModel-04678", + "text": " If the VulkanMemoryModel capability is not declared, the Volatile decoration must be used on any variable declaration that includes one of the SMIDNV, WarpIDNV, SubgroupSize, SubgroupLocalInvocationId, SubgroupEqMask, SubgroupGeMask, SubgroupGtMask, SubgroupLeMask, or SubgroupLtMask BuiltIn decorations when used in the ray generation, closest hit, miss, intersection, or callable shaders, or with the RayTmaxKHR Builtin decoration when used in an intersection shader" + }, + { + "vuid": "VUID-StandaloneSpirv-VulkanMemoryModel-04679", + "text": " If the VulkanMemoryModel capability is declared, the OpLoad instruction must use the Volatile memory semantics when it accesses into any variable that includes one of the SMIDNV, WarpIDNV, SubgroupSize, SubgroupLocalInvocationId, SubgroupEqMask, SubgroupGeMask, SubgroupGtMask, SubgroupLeMask, or SubgroupLtMask BuiltIn decorations when used in the ray generation, closest hit, miss, intersection, or callable shaders, or with the RayTmaxKHR Builtin decoration when used in an intersection shader" + }, + { + "vuid": "VUID-StandaloneSpirv-OpTypeRuntimeArray-04680", + "text": " OpTypeRuntimeArray must only be used for the last member of an OpTypeStruct that is in the StorageBuffer or PhysicalStorageBuffer storage class decorated as Block, or that is in the Uniform storage class decorated as BufferBlock" + }, + { + "vuid": "VUID-StandaloneSpirv-Function-04681", + "text": " A type T that is an array sized with a specialization constant must neither be, nor be contained in, the type T2 of a variable V, unless either: a) T is equal to T2, b) V is declared in the Function, or Private storage classes, c) V is a non-Block variable in the Workgroup storage class, or d) V is an interface variable with an additional level of arrayness, as described in interface matching, and T is the member type of the array type T2" + }, + { + "vuid": "VUID-StandaloneSpirv-OpControlBarrier-04682", + "text": " If OpControlBarrier is used in ray generation, intersection, any-hit, closest hit, miss, fragment, vertex, tessellation evaluation, or geometry shaders, the execution Scope must be Subgroup" + }, + { + "vuid": "VUID-StandaloneSpirv-LocalSize-06426", + "text": " For each compute shader entry point, either a LocalSize or LocalSizeId execution mode, or an object decorated with the WorkgroupSize decoration must be specified" + }, + { + "vuid": "VUID-StandaloneSpirv-DerivativeGroupQuadsNV-04684", + "text": " For compute shaders using the DerivativeGroupQuadsNV execution mode, the first two dimensions of the local workgroup size must be a multiple of two" + }, + { + "vuid": "VUID-StandaloneSpirv-DerivativeGroupLinearNV-04778", + "text": " For compute shaders using the DerivativeGroupLinearNV execution mode, the product of the dimensions of the local workgroup size must be a multiple of four" + }, + { + "vuid": "VUID-StandaloneSpirv-OpGroupNonUniformBallotBitCount-04685", + "text": " If OpGroupNonUniformBallotBitCount is used, the group operation must be limited to Reduce, InclusiveScan, or ExclusiveScan" + }, + { + "vuid": "VUID-StandaloneSpirv-None-04686", + "text": " The Pointer operand of all atomic instructions must have a Storage Class limited to Uniform, Workgroup, Image, StorageBuffer, or PhysicalStorageBuffer" + }, + { + "vuid": "VUID-StandaloneSpirv-Offset-04687", + "text": " Output variables or block members decorated with Offset that have a 64-bit type, or a composite type containing a 64-bit type, must specify an Offset value aligned to a 8 byte boundary" + }, + { + "vuid": "VUID-StandaloneSpirv-Offset-04689", + "text": " The size of any output block containing any member decorated with Offset that is a 64-bit type must be a multiple of 8" + }, + { + "vuid": "VUID-StandaloneSpirv-Offset-04690", + "text": " The first member of an output block specifying a Offset decoration must specify a Offset value that is aligned to an 8 byte boundary if that block contains any member decorated with Offset and is a 64-bit type" + }, + { + "vuid": "VUID-StandaloneSpirv-Offset-04691", + "text": " Output variables or block members decorated with Offset that have a 32-bit type, or a composite type contains a 32-bit type, must specify an Offset value aligned to a 4 byte boundary" + }, + { + "vuid": "VUID-StandaloneSpirv-Offset-04692", + "text": " Output variables, blocks or block members decorated with Offset must only contain base types that have components that are either 32-bit or 64-bit in size" + }, + { + "vuid": "VUID-StandaloneSpirv-Offset-04716", + "text": " Only variables or block members in the output interface decorated with Offset can be captured for transform feedback, and those variables or block members must also be decorated with XfbBuffer and XfbStride, or inherit XfbBuffer and XfbStride decorations from a block containing them" + }, + { + "vuid": "VUID-StandaloneSpirv-XfbBuffer-04693", + "text": " All variables or block members in the output interface of the entry point being compiled decorated with a specific XfbBuffer value must all be decorated with identical XfbStride values" + }, + { + "vuid": "VUID-StandaloneSpirv-Stream-04694", + "text": " If any variables or block members in the output interface of the entry point being compiled are decorated with Stream, then all variables belonging to the same XfbBuffer must specify the same Stream value" + }, + { + "vuid": "VUID-StandaloneSpirv-XfbBuffer-04696", + "text": " For any two variables or block members in the output interface of the entry point being compiled with the same XfbBuffer value, the ranges determined by the Offset decoration and the size of the type must not overlap" + }, + { + "vuid": "VUID-StandaloneSpirv-XfbBuffer-04697", + "text": " All block members in the output interface of the entry point being compiled that are in the same block and have a declared or inherited XfbBuffer decoration must specify the same XfbBuffer value" + }, + { + "vuid": "VUID-StandaloneSpirv-RayPayloadKHR-04698", + "text": " RayPayloadKHR storage class must only be used in ray generation, closest hit or miss shaders" + }, + { + "vuid": "VUID-StandaloneSpirv-IncomingRayPayloadKHR-04699", + "text": " IncomingRayPayloadKHR storage class must only be used in closest hit, any-hit, or miss shaders" + }, + { + "vuid": "VUID-StandaloneSpirv-IncomingRayPayloadKHR-04700", + "text": " There must be at most one variable with the IncomingRayPayloadKHR storage class in the input interface of an entry point" + }, + { + "vuid": "VUID-StandaloneSpirv-HitAttributeKHR-04701", + "text": " HitAttributeKHR storage class must only be used in intersection, any-hit, or closest hit shaders" + }, + { + "vuid": "VUID-StandaloneSpirv-HitAttributeKHR-04702", + "text": " There must be at most one variable with the HitAttributeKHR storage class in the input interface of an entry point" + }, + { + "vuid": "VUID-StandaloneSpirv-HitAttributeKHR-04703", + "text": " A variable with HitAttributeKHR storage class must only be written to in an intersection shader" + }, + { + "vuid": "VUID-StandaloneSpirv-CallableDataKHR-04704", + "text": " CallableDataKHR storage class must only be used in ray generation, closest hit, miss, and callable shaders" + }, + { + "vuid": "VUID-StandaloneSpirv-IncomingCallableDataKHR-04705", + "text": " IncomingCallableDataKHR storage class must only be used in callable shaders" + }, + { + "vuid": "VUID-StandaloneSpirv-IncomingCallableDataKHR-04706", + "text": " There must be at most one variable with the IncomingCallableDataKHR storage class in the input interface of an entry point" + }, + { + "vuid": "VUID-StandaloneSpirv-Base-04707", + "text": " The Base operand of OpPtrAccessChain must point to one of the following: Workgroup, if VariablePointers is enabled; StorageBuffer, if VariablePointers or VariablePointersStorageBuffer is enabled; PhysicalStorageBuffer, if the PhysicalStorageBuffer64 addressing model is enabled" + }, + { + "vuid": "VUID-StandaloneSpirv-PhysicalStorageBuffer64-04708", + "text": " If the PhysicalStorageBuffer64 addressing model is enabled, all instructions that support memory access operands and that use a physical pointer must include the Aligned operand" + }, + { + "vuid": "VUID-StandaloneSpirv-PhysicalStorageBuffer64-04709", + "text": " If the PhysicalStorageBuffer64 addressing model is enabled, any access chain instruction that accesses into a RowMajor matrix must only be used as the Pointer operand to OpLoad or OpStore" + }, + { + "vuid": "VUID-StandaloneSpirv-PhysicalStorageBuffer64-04710", + "text": " If the PhysicalStorageBuffer64 addressing model is enabled, OpConvertUToPtr and OpConvertPtrToU must use an integer type whose Width is 64" + }, + { + "vuid": "VUID-StandaloneSpirv-OpTypeForwardPointer-04711", + "text": " OpTypeForwardPointer must have a storage class of PhysicalStorageBuffer" + }, + { + "vuid": "VUID-StandaloneSpirv-None-04745", + "text": " All variables with a storage class of PushConstant declared as an array must only be accessed by dynamically uniform indices" + }, + { + "vuid": "VUID-StandaloneSpirv-Result-04780", + "text": " The Result Type operand of any OpImageRead or OpImageSparseRead instruction must be a vector of four components" + }, + { + "vuid": "VUID-StandaloneSpirv-Base-04781", + "text": " The Base operand of any OpBitCount, OpBitReverse, OpBitFieldInsert, OpBitFieldSExtract, or OpBitFieldUExtract instruction must be a 32-bit integer scalar or a vector of 32-bit integers" + }, + { + "vuid": "VUID-StandaloneSpirv-DescriptorSet-06491", + "text": " If a variable is decorated by DescriptorSet or Binding, the storage class must correspond to an entry in Shader Resource and Storage Class Correspondence" + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-StandaloneSpirv-None-04642", + "text": " Scope for group operations must be limited to Subgroup" + } + ] + }, + "RuntimeSpirv": { + "(VK_VERSION_1_2,VK_KHR_vulkan_memory_model)": [ + { + "vuid": "VUID-RuntimeSpirv-vulkanMemoryModel-06265", + "text": " If vulkanMemoryModel is enabled and vulkanMemoryModelDeviceScope is not enabled, Device memory scope must not be used." + }, + { + "vuid": "VUID-RuntimeSpirv-vulkanMemoryModel-06266", + "text": " If vulkanMemoryModel is not enabled, QueueFamily memory scope must not be used." + } + ], + "(VK_KHR_shader_clock)": [ + { + "vuid": "VUID-RuntimeSpirv-shaderSubgroupClock-06267", + "text": " If shaderSubgroupClock is not enabled, the Subgroup scope must not be used for OpReadClockKHR." + }, + { + "vuid": "VUID-RuntimeSpirv-shaderDeviceClock-06268", + "text": " If shaderDeviceClock is not enabled, the Device scope must not be used for OpReadClockKHR." + } + ], + "!(VK_KHR_format_feature_flags2)": [ + { + "vuid": "VUID-RuntimeSpirv-OpTypeImage-06269", + "text": " If shaderStorageImageWriteWithoutFormat is not enabled, any variable created with a “Type” of OpTypeImage that has a “Sampled” operand of 2 and an “Image Format” operand of Unknown must be decorated with NonWritable." + }, + { + "vuid": "VUID-RuntimeSpirv-OpTypeImage-06270", + "text": " If shaderStorageImageReadWithoutFormat is not enabled, any variable created with a “Type” of OpTypeImage that has a “Sampled” operand of 2 and an “Image Format” operand of Unknown must be decorated with NonReadable." + } + ], + "core": [ + { + "vuid": "VUID-RuntimeSpirv-Location-06272", + "text": " The sum of Location and the number of locations the variable it decorates consumes must be less than or equal to the value for the matching {ExecutionModel} defined in Shader Input and Output Locations" + }, + { + "vuid": "VUID-RuntimeSpirv-Fragment-06427", + "text": " When blending is enabled and one of the dual source blend modes is in use, the maximum number of output attachments written to in the Fragment {ExecutionModel} must be less than or equal to maxFragmentDualSrcAttachments" + }, + { + "vuid": "VUID-RuntimeSpirv-Location-06428", + "text": " The maximum number of storage buffers, storage images, and output Location decorated color attachments written to in the Fragment {ExecutionModel} must be less than or equal to maxFragmentCombinedOutputResources" + }, + { + "vuid": "VUID-RuntimeSpirv-DescriptorSet-06323", + "text": " DescriptorSet and Binding decorations must obey the constraints on storage class, type, and descriptor type described in DescriptorSet and Binding Assignment" + }, + { + "vuid": "VUID-RuntimeSpirv-NonWritable-06340", + "text": " If fragmentStoresAndAtomics is not enabled, then all storage image, storage texel buffer, and storage buffer variables in the fragment stage must be decorated with the NonWritable decoration." + }, + { + "vuid": "VUID-RuntimeSpirv-NonWritable-06341", + "text": " If vertexPipelineStoresAndAtomics is not enabled, then all storage image, storage texel buffer, and storage buffer variables in the vertex, tessellation, and geometry stages must be decorated with the NonWritable decoration." + }, + { + "vuid": "VUID-RuntimeSpirv-None-06342", + "text": " If subgroupQuadOperationsInAllStages is VK_FALSE, then quad subgroup operations must not be used except for in fragment and compute stages." + }, + { + "vuid": "VUID-RuntimeSpirv-Offset-06344", + "text": " The first element of the Offset operand of InterpolateAtOffset must be greater than or equal to:" + }, + { + "vuid": "VUID-RuntimeSpirv-Offset-06345", + "text": " The first element of the Offset operand of InterpolateAtOffset must be less than or equal to:" + }, + { + "vuid": "VUID-RuntimeSpirv-Offset-06346", + "text": " The second element of the Offset operand of InterpolateAtOffset must be greater than or equal to:" + }, + { + "vuid": "VUID-RuntimeSpirv-Offset-06347", + "text": " The second element of the Offset operand of InterpolateAtOffset must be less than or equal to:" + }, + { + "vuid": "VUID-RuntimeSpirv-x-06429", + "text": " The x size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupSize[0]" + }, + { + "vuid": "VUID-RuntimeSpirv-y-06430", + "text": " The y size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupSize[1]" + }, + { + "vuid": "VUID-RuntimeSpirv-z-06431", + "text": " The z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupSize[2]" + }, + { + "vuid": "VUID-RuntimeSpirv-x-06432", + "text": " The product of x size, y size, and z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupInvocations" + }, + { + "vuid": "VUID-RuntimeSpirv-OpImage-06376", + "text": " If an OpImage*Gather operation has an image operand of Offset, ConstOffset, or ConstOffsets the offset value must be greater than or equal to minTexelGatherOffset" + }, + { + "vuid": "VUID-RuntimeSpirv-OpImage-06377", + "text": " If an OpImage*Gather operation has an image operand of Offset, ConstOffset, or ConstOffsets the offset value must be less than or equal to maxTexelGatherOffset" + }, + { + "vuid": "VUID-RuntimeSpirv-OpImageSample-06435", + "text": " If an OpImageSample* or OpImageFetch* operation has an image operand of ConstOffset then the offset value must be greater than or equal to minTexelOffset" + }, + { + "vuid": "VUID-RuntimeSpirv-OpImageSample-06436", + "text": " If an OpImageSample* or OpImageFetch* operation has an image operand of ConstOffset then the offset value must be less than or equal to maxTexelOffset" + } + ], + "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [ + { + "vuid": "VUID-RuntimeSpirv-OpTypeRuntimeArray-06273", + "text": " OpTypeRuntimeArray must only be used for an array of variables with storage class Uniform, StorageBuffer, or UniformConstant, or for the outermost dimension of an array of arrays of such variables if the runtimeDescriptorArray feature is enabled," + }, + { + "vuid": "VUID-RuntimeSpirv-NonUniform-06274", + "text": " If an instruction loads from or stores to a resource (including atomics and image instructions) and the resource descriptor being accessed is not dynamically uniform, then the operand corresponding to that resource (e.g. the pointer or sampled image operand) must be decorated with NonUniform." + } + ], + "(VK_VERSION_1_1)+(VK_VERSION_1_2,VK_KHR_shader_subgroup_extended_types)": [ + { + "vuid": "VUID-RuntimeSpirv-None-06275", + "text": " shaderSubgroupExtendedTypes must be enabled for group operations to use 8-bit integer, 16-bit integer, 64-bit integer, 16-bit floating-point, and vectors of these types" + } + ], + "(VK_VERSION_1_2)": [ + { + "vuid": "VUID-RuntimeSpirv-subgroupBroadcastDynamicId-06276", + "text": " If subgroupBroadcastDynamicId is VK_TRUE, and the shader module version is 1.5 or higher, the “Index” for OpGroupNonUniformQuadBroadcast must be dynamically uniform within the derivative group. Otherwise, “Index” must be a constant." + }, + { + "vuid": "VUID-RuntimeSpirv-subgroupBroadcastDynamicId-06277", + "text": " If subgroupBroadcastDynamicId is VK_TRUE, and the shader module version is 1.5 or higher, the “Id” for OpGroupNonUniformBroadcast must be dynamically uniform within the subgroup. Otherwise, “Id” must be a constant." + } + ], + "(VK_KHR_shader_atomic_int64)": [ + { + "vuid": "VUID-RuntimeSpirv-None-06278", + "text": " shaderBufferInt64Atomics must be enabled for 64-bit integer atomic operations to be supported on a Pointer with a Storage Class of StorageBuffer or Uniform." + }, + { + "vuid": "VUID-RuntimeSpirv-None-06279", + "text": " shaderSharedInt64Atomics must be enabled for 64-bit integer atomic operations to be supported on a Pointer with a Storage Class of Workgroup." + } + ], + "(VK_EXT_shader_atomic_float)+!(VK_EXT_shader_atomic_float2)": [ + { + "vuid": "VUID-RuntimeSpirv-None-06280", + "text": " shaderBufferFloat32Atomics, or shaderBufferFloat32AtomicAdd, or shaderBufferFloat64Atomics, or shaderBufferFloat64AtomicAdd must be enabled for floating-point atomic operations to be supported on a Pointer with a Storage Class of StorageBuffer." + }, + { + "vuid": "VUID-RuntimeSpirv-None-06281", + "text": " shaderSharedFloat32Atomics, or shaderSharedFloat32AtomicAdd, or shaderSharedFloat64Atomics, or shaderSharedFloat64AtomicAdd must be enabled for floating-point atomic operations to be supported on a Pointer with a Storage Class of Workgroup." + }, + { + "vuid": "VUID-RuntimeSpirv-None-06282", + "text": " shaderImageFloat32Atomics or shaderImageFloat32AtomicAdd must be enabled for 32-bit floating-point atomic operations to be supported on a Pointer with a Storage Class of Image." + }, + { + "vuid": "VUID-RuntimeSpirv-None-06283", + "text": " sparseImageFloat32Atomics or sparseImageFloat32AtomicAdd must be enabled for 32-bit floating-point atomics to be supported on sparse images." + }, + { + "vuid": "VUID-RuntimeSpirv-None-06335", + "text": " shaderBufferFloat32Atomics, or shaderBufferFloat32AtomicAdd, or shaderSharedFloat32Atomics, or shaderSharedFloat32AtomicAdd, or shaderImageFloat32Atomics, or shaderImageFloat32AtomicAdd must be enabled for 32-bit floating point atomic operations" + }, + { + "vuid": "VUID-RuntimeSpirv-None-06336", + "text": " shaderBufferFloat64Atomics, or shaderBufferFloat64AtomicAdd, or shaderSharedFloat64Atomics, or shaderSharedFloat64AtomicAdd must be enabled for 64-bit floating point atomic operations" + } + ], + "(VK_EXT_shader_atomic_float2)": [ + { + "vuid": "VUID-RuntimeSpirv-None-06284", + "text": " shaderBufferFloat32Atomics, or shaderBufferFloat32AtomicAdd, or shaderBufferFloat64Atomics, or shaderBufferFloat64AtomicAdd, or shaderBufferFloat16Atomics, or shaderBufferFloat16AtomicAdd, or shaderBufferFloat16AtomicMinMax, or shaderBufferFloat32AtomicMinMax, or shaderBufferFloat64AtomicMinMax must be enabled for floating-point atomic operations to be supported on a Pointer with a Storage Class of StorageBuffer." + }, + { + "vuid": "VUID-RuntimeSpirv-None-06285", + "text": " shaderSharedFloat32Atomics, or shaderSharedFloat32AtomicAdd, or shaderSharedFloat64Atomics, or shaderSharedFloat64AtomicAdd, or shaderSharedFloat16Atomics, or shaderSharedFloat16AtomicAdd, or shaderSharedFloat16AtomicMinMax, or shaderSharedFloat32AtomicMinMax, or shaderSharedFloat64AtomicMinMax must be enabled for floating-point atomic operations to be supported on a Pointer with a Storage Class of Workgroup." + }, + { + "vuid": "VUID-RuntimeSpirv-None-06286", + "text": " shaderImageFloat32Atomics, or shaderImageFloat32AtomicAdd, or shaderImageFloat32AtomicMinMax must be enabled for 32-bit floating-point atomic operations to be supported on a Pointer with a Storage Class of Image." + }, + { + "vuid": "VUID-RuntimeSpirv-None-06287", + "text": " sparseImageFloat32Atomics, or sparseImageFloat32AtomicAdd, or sparseImageFloat32AtomicMinMax must be enabled for 32-bit floating-point atomics to be supported on sparse images." + }, + { + "vuid": "VUID-RuntimeSpirv-None-06337", + "text": " shaderBufferFloat16Atomics, or shaderBufferFloat16AtomicAdd, or shaderBufferFloat16AtomicMinMax, or shaderSharedFloat16Atomics, or shaderSharedFloat16AtomicAdd, or shaderSharedFloat16AtomicMinMax must be enabled for 16-bit floating point atomic operations" + }, + { + "vuid": "VUID-RuntimeSpirv-None-06338", + "text": " shaderBufferFloat32Atomics, or shaderBufferFloat32AtomicAdd, or shaderSharedFloat32Atomics, or shaderSharedFloat32AtomicAdd, or shaderImageFloat32Atomics, or shaderImageFloat32AtomicAdd or shaderBufferFloat32AtomicMinMax, or shaderSharedFloat32AtomicMinMax, or shaderImageFloat32AtomicMinMax must be enabled for 32-bit floating point atomic operations" + }, + { + "vuid": "VUID-RuntimeSpirv-None-06339", + "text": " shaderBufferFloat64Atomics, or shaderBufferFloat64AtomicAdd, or shaderSharedFloat64Atomics, or shaderSharedFloat64AtomicAdd, or shaderBufferFloat64AtomicMinMax, or shaderSharedFloat64AtomicMinMax, must be enabled for 64-bit floating point atomic operations" + } + ], + "(VK_EXT_shader_image_atomic_int64)": [ + { + "vuid": "VUID-RuntimeSpirv-None-06288", + "text": " shaderImageInt64Atomics must be enabled for 64-bit integer atomic operations to be supported on a Pointer with a Storage Class of Image." + } + ], + "(VK_VERSION_1_2,VK_KHR_shader_float_controls)": [ + { + "vuid": "VUID-RuntimeSpirv-denormBehaviorIndependence-06289", + "text": " If denormBehaviorIndependence is VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY, then the entry point must use the same denormals execution mode for both 16-bit and 64-bit floating-point types." + }, + { + "vuid": "VUID-RuntimeSpirv-denormBehaviorIndependence-06290", + "text": " If denormBehaviorIndependence is VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE, then the entry point must use the same denormals execution mode for all floating-point types." + }, + { + "vuid": "VUID-RuntimeSpirv-roundingModeIndependence-06291", + "text": " If roundingModeIndependence is VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY, then the entry point must use the same rounding execution mode for both 16-bit and 64-bit floating-point types." + }, + { + "vuid": "VUID-RuntimeSpirv-roundingModeIndependence-06292", + "text": " If roundingModeIndependence is VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE, then the entry point must use the same rounding execution mode for all floating-point types." + }, + { + "vuid": "VUID-RuntimeSpirv-shaderSignedZeroInfNanPreserveFloat16-06293", + "text": " If shaderSignedZeroInfNanPreserveFloat16 is VK_FALSE, then SignedZeroInfNanPreserve for 16-bit floating-point type must not be used." + }, + { + "vuid": "VUID-RuntimeSpirv-shaderSignedZeroInfNanPreserveFloat32-06294", + "text": " If shaderSignedZeroInfNanPreserveFloat32 is VK_FALSE, then SignedZeroInfNanPreserve for 32-bit floating-point type must not be used." + }, + { + "vuid": "VUID-RuntimeSpirv-shaderSignedZeroInfNanPreserveFloat64-06295", + "text": " If shaderSignedZeroInfNanPreserveFloat64 is VK_FALSE, then SignedZeroInfNanPreserve for 64-bit floating-point type must not be used." + }, + { + "vuid": "VUID-RuntimeSpirv-shaderDenormPreserveFloat16-06296", + "text": " If shaderDenormPreserveFloat16 is VK_FALSE, then DenormPreserve for 16-bit floating-point type must not be used." + }, + { + "vuid": "VUID-RuntimeSpirv-shaderDenormPreserveFloat32-06297", + "text": " If shaderDenormPreserveFloat32 is VK_FALSE, then DenormPreserve for 32-bit floating-point type must not be used." + }, + { + "vuid": "VUID-RuntimeSpirv-shaderDenormPreserveFloat64-06298", + "text": " If shaderDenormPreserveFloat64 is VK_FALSE, then DenormPreserve for 64-bit floating-point type must not be used." + }, + { + "vuid": "VUID-RuntimeSpirv-shaderDenormFlushToZeroFloat16-06299", + "text": " If shaderDenormFlushToZeroFloat16 is VK_FALSE, then DenormFlushToZero for 16-bit floating-point type must not be used." + }, + { + "vuid": "VUID-RuntimeSpirv-shaderDenormFlushToZeroFloat32-06300", + "text": " If shaderDenormFlushToZeroFloat32 is VK_FALSE, then DenormFlushToZero for 32-bit floating-point type must not be used." + }, + { + "vuid": "VUID-RuntimeSpirv-shaderDenormFlushToZeroFloat64-06301", + "text": " If shaderDenormFlushToZeroFloat64 is VK_FALSE, then DenormFlushToZero for 64-bit floating-point type must not be used." + }, + { + "vuid": "VUID-RuntimeSpirv-shaderRoundingModeRTEFloat16-06302", + "text": " If shaderRoundingModeRTEFloat16 is VK_FALSE, then RoundingModeRTE for 16-bit floating-point type must not be used." + }, + { + "vuid": "VUID-RuntimeSpirv-shaderRoundingModeRTEFloat32-06303", + "text": " If shaderRoundingModeRTEFloat32 is VK_FALSE, then RoundingModeRTE for 32-bit floating-point type must not be used." + }, + { + "vuid": "VUID-RuntimeSpirv-shaderRoundingModeRTEFloat64-06304", + "text": " If shaderRoundingModeRTEFloat64 is VK_FALSE, then RoundingModeRTE for 64-bit floating-point type must not be used." + }, + { + "vuid": "VUID-RuntimeSpirv-shaderRoundingModeRTZFloat16-06305", + "text": " If shaderRoundingModeRTZFloat16 is VK_FALSE, then RoundingModeRTZ for 16-bit floating-point type must not be used." + }, + { + "vuid": "VUID-RuntimeSpirv-shaderRoundingModeRTZFloat32-06306", + "text": " If shaderRoundingModeRTZFloat32 is VK_FALSE, then RoundingModeRTZ for 32-bit floating-point type must not be used." + }, + { + "vuid": "VUID-RuntimeSpirv-shaderRoundingModeRTZFloat64-06307", + "text": " If shaderRoundingModeRTZFloat64 is VK_FALSE, then RoundingModeRTZ for 64-bit floating-point type must not be used." + } + ], + "(VK_EXT_transform_feedback)": [ + { + "vuid": "VUID-RuntimeSpirv-Offset-06308", + "text": " The Offset plus size of the type of each variable, in the output interface of the entry point being compiled, decorated with XfbBuffer must not be greater than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBufferDataSize" + }, + { + "vuid": "VUID-RuntimeSpirv-XfbBuffer-06309", + "text": " For any given XfbBuffer value, define the buffer data size to be smallest number of bytes such that, for all outputs decorated with the same XfbBuffer value, the size of the output interface variable plus the Offset is less than or equal to the buffer data size. For a given Stream, the sum of all the buffer data sizes for all buffers writing to that stream the must not exceed VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreamDataSize" + }, + { + "vuid": "VUID-RuntimeSpirv-OpEmitStreamVertex-06310", + "text": " The Stream value to OpEmitStreamVertex and OpEndStreamPrimitive must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreams" + }, + { + "vuid": "VUID-RuntimeSpirv-transformFeedbackStreamsLinesTriangles-06311", + "text": " If the geometry shader emits to more than one vertex stream and VkPhysicalDeviceTransformFeedbackPropertiesEXT::transformFeedbackStreamsLinesTriangles is VK_FALSE, then execution mode must be OutputPoints" + }, + { + "vuid": "VUID-RuntimeSpirv-Stream-06312", + "text": " The stream number value to Stream must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreams" + }, + { + "vuid": "VUID-RuntimeSpirv-XfbStride-06313", + "text": " The XFB Stride value to XfbStride must be less than or equal to VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBufferDataStride" + } + ], + "(VK_VERSION_1_2,VK_EXT_buffer_device_address,VK_KHR_buffer_device_address)": [ + { + "vuid": "VUID-RuntimeSpirv-PhysicalStorageBuffer64-06314", + "text": " If the PhysicalStorageBuffer64 addressing model is enabled any load or store through a physical pointer type must be aligned to a multiple of the size of the largest scalar type in the pointed-to type." + }, + { + "vuid": "VUID-RuntimeSpirv-PhysicalStorageBuffer64-06315", + "text": " If the PhysicalStorageBuffer64 addressing model is enabled the pointer value of a memory access instruction must be at least as aligned as specified by the Aligned memory access operand." + } + ], + "(VK_NV_cooperative_matrix)": [ + { + "vuid": "VUID-RuntimeSpirv-OpTypeCooperativeMatrixNV-06316", + "text": " For OpTypeCooperativeMatrixNV, the component type, scope, number of rows, and number of columns must match one of the matrices in any of the supported VkCooperativeMatrixPropertiesNV." + }, + { + "vuid": "VUID-RuntimeSpirv-OpCooperativeMatrixMulAddNV-06317", + "text": " For OpCooperativeMatrixMulAddNV, the type of A must have VkCooperativeMatrixPropertiesNV::MSize rows and VkCooperativeMatrixPropertiesNV::KSize columns and have a component type that matches VkCooperativeMatrixPropertiesNV::AType." + }, + { + "vuid": "VUID-RuntimeSpirv-OpCooperativeMatrixMulAddNV-06318", + "text": " For OpCooperativeMatrixMulAddNV, the type of B must have VkCooperativeMatrixPropertiesNV::KSize rows and VkCooperativeMatrixPropertiesNV::NSize columns and have a component type that matches VkCooperativeMatrixPropertiesNV::BType." + }, + { + "vuid": "VUID-RuntimeSpirv-OpCooperativeMatrixMulAddNV-06319", + "text": " For OpCooperativeMatrixMulAddNV, the type of C must have VkCooperativeMatrixPropertiesNV::MSize rows and VkCooperativeMatrixPropertiesNV::NSize columns and have a component type that matches VkCooperativeMatrixPropertiesNV::CType." + }, + { + "vuid": "VUID-RuntimeSpirv-OpCooperativeMatrixMulAddNV-06320", + "text": " For OpCooperativeMatrixMulAddNV, the type of Result must have VkCooperativeMatrixPropertiesNV::MSize rows and VkCooperativeMatrixPropertiesNV::NSize columns and have a component type that matches VkCooperativeMatrixPropertiesNV::DType." + }, + { + "vuid": "VUID-RuntimeSpirv-OpCooperativeMatrixMulAddNV-06321", + "text": " For OpCooperativeMatrixMulAddNV, the type of A, B, C, and Result must all have a scope of scope." + }, + { + "vuid": "VUID-RuntimeSpirv-OpTypeCooperativeMatrixNV-06322", + "text": " OpTypeCooperativeMatrixNV and OpCooperativeMatrix* instructions must not be used in shader stages not included in VkPhysicalDeviceCooperativeMatrixPropertiesNV::cooperativeMatrixSupportedStages." + }, + { + "vuid": "VUID-RuntimeSpirv-OpCooperativeMatrixLoadNV-06324", + "text": " For OpCooperativeMatrixLoadNV and OpCooperativeMatrixStoreNV instructions, the Pointer and Stride operands must be aligned to at least the lesser of 16 bytes or the natural alignment of a row or column (depending on ColumnMajor) of the matrix (where the natural alignment is the number of columns/rows multiplied by the component size)." + } + ], + "(VK_KHR_portability_subset)": [ + { + "vuid": "VUID-RuntimeSpirv-shaderSampleRateInterpolationFunctions-06325", + "text": " If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::shaderSampleRateInterpolationFunctions is VK_FALSE, then GLSL.std.450 fragment interpolation functions are not supported by the implementation and OpCapability must not be set to InterpolationFunction." + }, + { + "vuid": "VUID-RuntimeSpirv-tessellationShader-06326", + "text": " If tessellationShader is enabled, and the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::tessellationIsolines is VK_FALSE, then OpExecutionMode must not be set to IsoLines." + }, + { + "vuid": "VUID-RuntimeSpirv-tessellationShader-06327", + "text": " If tessellationShader is enabled, and the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::tessellationPointMode is VK_FALSE, then OpExecutionMode must not be set to PointMode." + } + ], + "(VK_KHR_8bit_storage)": [ + { + "vuid": "VUID-RuntimeSpirv-storageBuffer8BitAccess-06328", + "text": " If storageBuffer8BitAccess is VK_FALSE, then objects containing an 8-bit integer element must not have storage class of StorageBuffer, ShaderRecordBufferKHR, or PhysicalStorageBuffer." + }, + { + "vuid": "VUID-RuntimeSpirv-uniformAndStorageBuffer8BitAccess-06329", + "text": " If uniformAndStorageBuffer8BitAccess is VK_FALSE, then objects in the Uniform storage class with the Block decoration must not have an 8-bit integer member." + }, + { + "vuid": "VUID-RuntimeSpirv-storagePushConstant8-06330", + "text": " If storagePushConstant8 is VK_FALSE, then objects containing an 8-bit integer element must not have storage class of PushConstant." + } + ], + "(VK_KHR_16bit_storage)": [ + { + "vuid": "VUID-RuntimeSpirv-storageBuffer16BitAccess-06331", + "text": " If storageBuffer16BitAccess is VK_FALSE, then objects containing 16-bit integer or 16-bit floating-point elements must not have storage class of StorageBuffer, ShaderRecordBufferKHR, or PhysicalStorageBuffer." + }, + { + "vuid": "VUID-RuntimeSpirv-uniformAndStorageBuffer16BitAccess-06332", + "text": " If uniformAndStorageBuffer16BitAccess is VK_FALSE, then objects in the Uniform storage class with the Block decoration must not have 16-bit integer or 16-bit floating-point members." + }, + { + "vuid": "VUID-RuntimeSpirv-storagePushConstant16-06333", + "text": " If storagePushConstant16 is VK_FALSE, then objects containing 16-bit integer or 16-bit floating-point elements must not have storage class of PushConstant." + }, + { + "vuid": "VUID-RuntimeSpirv-storageInputOutput16-06334", + "text": " If storageInputOutput16 is VK_FALSE, then objects containing 16-bit integer or 16-bit floating-point elements must not have storage class of Input or Output." + } + ], + "(VKSC_VERSION_1_0)": [ + { + "vuid": "VUID-RuntimeSpirv-OpAtomic-05091", + "text": " If shaderAtomicInstructions is not enabled, the SPIR-V Atomic Instructions listed in 3.37.18 (OpAtomic*) must not be used [SCID-1]." + } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-RuntimeSpirv-None-06343", + "text": " Group operations with subgroup scope must not be used if the shader stage is not in subgroupSupportedStages." + } + ], + "(VK_KHR_ray_query)": [ + { + "vuid": "VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06348", + "text": " For OpRayQueryInitializeKHR instructions, all components of the RayOrigin and RayDirection operands must be finite floating-point values." + }, + { + "vuid": "VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06349", + "text": " For OpRayQueryInitializeKHR instructions, the RayTmin and RayTmax operands must be non-negative floating-point values." + }, + { + "vuid": "VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06350", + "text": " For OpRayQueryInitializeKHR instructions, the RayTmin operand must be less than or equal to the RayTmax operand." + }, + { + "vuid": "VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06351", + "text": " For OpRayQueryInitializeKHR instructions, RayOrigin, RayDirection, RayTmin, and RayTmax operands must not contain NaNs." + }, + { + "vuid": "VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06352", + "text": " For OpRayQueryInitializeKHR instructions, Acceleration Structure must be an acceleration structure built as a top-level acceleration structure." + }, + { + "vuid": "VUID-RuntimeSpirv-OpRayQueryGenerateIntersectionKHR-06353", + "text": " For OpRayQueryGenerateIntersectionKHR instructions, Hit T must satisfy the condition RayTmin {leq} Hit T {leq} RayTmax, where RayTmin is equal to the value returned by OpRayQueryGetRayTMinKHR with the same ray query object, and RayTmax is equal to the value of OpRayQueryGetIntersectionTKHR for the current committed intersection with the same ray query object." + } + ], + "(VK_KHR_ray_query)+(VK_NV_ray_tracing_motion_blur)": [ + { + "vuid": "VUID-RuntimeSpirv-OpRayQueryGenerateIntersectionKHR-06354", + "text": " For OpRayQueryGenerateIntersectionKHR instructions, Acceleration Structure must not be built with VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV in flags." + } + ], + "(VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-RuntimeSpirv-OpTraceRayKHR-06355", + "text": " For OpTraceRayKHR instructions, all components of the RayOrigin and RayDirection operands must be finite floating-point values." + }, + { + "vuid": "VUID-RuntimeSpirv-OpTraceRayKHR-06356", + "text": " For OpTraceRayKHR instructions, the RayTmin and RayTmax operands must be non-negative floating-point values." + }, + { + "vuid": "VUID-RuntimeSpirv-OpTraceRayKHR-06357", + "text": " For OpTraceRayKHR instructions, the RayTmin operand must be less than or equal to the RayTmax operand." + }, + { + "vuid": "VUID-RuntimeSpirv-OpTraceRayKHR-06358", + "text": " For OpTraceRayKHR instructions, RayOrigin, RayDirection, RayTmin, and RayTmax operands must not contain NaNs." + }, + { + "vuid": "VUID-RuntimeSpirv-OpTraceRayKHR-06359", + "text": " For OpTraceRayKHR instructions, Acceleration Structure must be an acceleration structure built as a top-level acceleration structure." + } + ], + "(VK_NV_ray_tracing_motion_blur)": [ + { + "vuid": "VUID-RuntimeSpirv-OpTraceRayKHR-06360", + "text": " For OpTraceRayKHR instructions, if Acceleration Structure was built with VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV in flags, the pipeline must have been created with VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV set" + }, + { + "vuid": "VUID-RuntimeSpirv-OpTraceRayMotionNV-06361", + "text": " For OpTraceRayMotionNV instructions, all components of the RayOrigin and RayDirection operands must be finite floating-point values." + }, + { + "vuid": "VUID-RuntimeSpirv-OpTraceRayMotionNV-06362", + "text": " For OpTraceRayMotionNV instructions, the RayTmin and RayTmax operands must be non-negative floating-point values." + }, + { + "vuid": "VUID-RuntimeSpirv-OpTraceRayMotionNV-06363", + "text": " For OpTraceRayMotionNV instructions, the RayTmin operand must be less than or equal to the RayTmax operand." + }, + { + "vuid": "VUID-RuntimeSpirv-OpTraceRayMotionNV-06364", + "text": " For OpTraceRayMotionNV instructions, RayOrigin, RayDirection, RayTmin, and RayTmax operands must not contain NaNs." + }, + { + "vuid": "VUID-RuntimeSpirv-OpTraceRayMotionNV-06365", + "text": " For OpTraceRayMotionNV instructions, Acceleration Structure must be an acceleration structure built as a top-level acceleration structure with VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV in flags" + }, + { + "vuid": "VUID-RuntimeSpirv-OpTraceRayMotionNV-06366", + "text": " For OpTraceRayMotionNV instructions the time operand must be between 0.0 and 1.0" + }, + { + "vuid": "VUID-RuntimeSpirv-OpTraceRayMotionNV-06367", + "text": " For OpTraceRayMotionNV instructions the pipeline must have been created with VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV set" + } + ], + "!(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-RuntimeSpirv-LocalSizeId-06433", + "text": " The execution mode LocalSizeId must not be used" + } + ], + "(VK_KHR_maintenance4)": [ + { + "vuid": "VUID-RuntimeSpirv-LocalSizeId-06434", + "text": " if execution mode LocalSizeId is used, maintenance4 must be enabled" + } + ], + "(VK_KHR_zero_initialize_workgroup_memory)": [ + { + "vuid": "VUID-RuntimeSpirv-shaderZeroInitializeWorkgroupMemory-06372", + "text": " If shaderZeroInitializeWorkgroupMemory is not enabled, any OpVariable with Workgroup as its Storage Class must not have an Initializer operand" + } + ], + "!(VK_KHR_zero_initialize_workgroup_memory)": [ + { + "vuid": "VUID-RuntimeSpirv-OpVariable-06373", + "text": " Any OpVariable with Workgroup as its Storage Class must not have an Initializer operand" + } + ], + "(VK_QCOM_render_pass_shader_resolve)": [ + { + "vuid": "VUID-RuntimeSpirv-SampleRateShading-06378", + "text": " If the subpass description contains VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM, then the SPIR-V fragment shader Capability SampleRateShading must not be enabled." + } + ], + "(VK_KHR_shader_subgroup_uniform_control_flow)": [ + { + "vuid": "VUID-RuntimeSpirv-SubgroupUniformControlFlowKHR-06379", + "text": " The execution mode SubgroupUniformControlFlowKHR must not be applied to an entry point unless shaderSubgroupUniformControlFlow is enabled and the corresponding shader stage bit is set in subgroup supportedStages and the entry point does not execute any invocation repack instructions." + } + ] + } + } +} \ No newline at end of file diff --git a/registry/vk.xml b/registry/vk.xml new file mode 100644 index 0000000..51a8a3b --- /dev/null +++ b/registry/vk.xml @@ -0,0 +1,20057 @@ + + + +Copyright 2015-2021 The Khronos Group Inc. + +SPDX-License-Identifier: Apache-2.0 OR MIT + + + +This file, vk.xml, is the Vulkan API Registry. It is a critically important +and normative part of the Vulkan Specification, including a canonical +machine-readable definition of the API, parameter and member validation +language incorporated into the Specification and reference pages, and other +material which is registered by Khronos, such as tags used by extension and +layer authors. The authoritative public version of vk.xml is maintained in +the default branch (currently named main) of the Khronos Vulkan GitHub +project. The authoritative private version is maintained in the default +branch of the member gitlab server. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + #include "vk_platform.h" + + WSI extensions + + + + + + + + + + + + In the current header structure, each platform's interfaces + are confined to a platform-specific header (vulkan_xlib.h, + vulkan_win32.h, etc.). These headers are not self-contained, + and should not include native headers (X11/Xlib.h, + windows.h, etc.). Code should either include vulkan.h after + defining the appropriate VK_USE_PLATFORM_platform + macros, or include the required native headers prior to + explicitly including the corresponding platform header. + + To accomplish this, the dependencies of native types require + native headers, but the XML defines the content for those + native headers as empty. The actual native header includes + can be restored by modifying the native header tags above + to #include the header file in the 'name' attribute. + + + + + + + + + + + + + + + + + + + + + + + + + + + // DEPRECATED: This define is deprecated. VK_MAKE_API_VERSION should be used instead. +#define VK_MAKE_VERSION(major, minor, patch) \ + ((((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch))) + // DEPRECATED: This define is deprecated. VK_API_VERSION_MAJOR should be used instead. +#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22) + // DEPRECATED: This define is deprecated. VK_API_VERSION_MINOR should be used instead. +#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3FFU) + // DEPRECATED: This define is deprecated. VK_API_VERSION_PATCH should be used instead. +#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU) + + #define VK_MAKE_API_VERSION(variant, major, minor, patch) \ + ((((uint32_t)(variant)) << 29) | (((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch))) + #define VK_API_VERSION_VARIANT(version) ((uint32_t)(version) >> 29) + #define VK_API_VERSION_MAJOR(version) (((uint32_t)(version) >> 22) & 0x7FU) + #define VK_API_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3FFU) + #define VK_API_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU) + + // Vulkan SC variant number +#define VKSC_API_VARIANT 1 + + // DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead. +//#define VK_API_VERSION VK_MAKE_API_VERSION(0, 1, 0, 0) // Patch version should always be set to 0 + // Vulkan 1.0 version number +#define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0 + // Vulkan 1.1 version number +#define VK_API_VERSION_1_1 VK_MAKE_API_VERSION(0, 1, 1, 0)// Patch version should always be set to 0 + // Vulkan 1.2 version number +#define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0)// Patch version should always be set to 0 + // Vulkan SC 1.0 version number +#define VKSC_API_VERSION_1_0 VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, 0)// Patch version should always be set to 0 + + // Version of this file +#define VK_HEADER_VERSION 202 + // Complete version of this file +#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 2, VK_HEADER_VERSION) + + // Version of this file +#define VK_HEADER_VERSION 9 + // Complete version of this file +#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, VK_HEADER_VERSION) + + +#define VK_DEFINE_HANDLE(object) typedef struct object##_T* (object); + + +#ifndef VK_USE_64_BIT_PTR_DEFINES + #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) + #define VK_USE_64_BIT_PTR_DEFINES 1 + #else + #define VK_USE_64_BIT_PTR_DEFINES 0 + #endif +#endif + +#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE + #if (VK_USE_64_BIT_PTR_DEFINES==1) + #if (defined(__cplusplus) && (__cplusplus >= 201103L)) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201103L)) + #define VK_NULL_HANDLE nullptr + #else + #define VK_NULL_HANDLE ((void*)0) + #endif + #else + #define VK_NULL_HANDLE 0ULL + #endif +#endif +#ifndef VK_NULL_HANDLE + #define VK_NULL_HANDLE 0 +#endif + +#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE + #if (VK_USE_64_BIT_PTR_DEFINES==1) + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *(object); + #else + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t (object); + #endif +#endif + + struct ANativeWindow; + struct AHardwareBuffer; + +#ifdef __OBJC__ +@class CAMetalLayer; +#else +typedef void CAMetalLayer; +#endif + + typedef uint32_t VkSampleMask; + typedef uint32_t VkBool32; + typedef uint32_t VkFlags; + typedef uint64_t VkFlags64; + typedef uint64_t VkDeviceSize; + typedef uint64_t VkDeviceAddress; + + Basic C types, pulled in via vk_platform.h + + + + + + + + + + + + + + + + Bitmask types + typedef VkFlags VkFramebufferCreateFlags; + typedef VkFlags VkQueryPoolCreateFlags; + typedef VkFlags VkRenderPassCreateFlags; + typedef VkFlags VkSamplerCreateFlags; + typedef VkFlags VkPipelineLayoutCreateFlags; + typedef VkFlags VkPipelineCacheCreateFlags; + typedef VkFlags VkPipelineDepthStencilStateCreateFlags; + typedef VkFlags VkPipelineDepthStencilStateCreateFlags; + typedef VkFlags VkPipelineDynamicStateCreateFlags; + typedef VkFlags VkPipelineColorBlendStateCreateFlags; + typedef VkFlags VkPipelineColorBlendStateCreateFlags; + typedef VkFlags VkPipelineMultisampleStateCreateFlags; + typedef VkFlags VkPipelineRasterizationStateCreateFlags; + typedef VkFlags VkPipelineViewportStateCreateFlags; + typedef VkFlags VkPipelineTessellationStateCreateFlags; + typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; + typedef VkFlags VkPipelineVertexInputStateCreateFlags; + typedef VkFlags VkPipelineShaderStageCreateFlags; + typedef VkFlags VkDescriptorSetLayoutCreateFlags; + typedef VkFlags VkBufferViewCreateFlags; + typedef VkFlags VkInstanceCreateFlags; + typedef VkFlags VkDeviceCreateFlags; + typedef VkFlags VkDeviceQueueCreateFlags; + typedef VkFlags VkQueueFlags; + typedef VkFlags VkMemoryPropertyFlags; + typedef VkFlags VkMemoryHeapFlags; + typedef VkFlags VkAccessFlags; + typedef VkFlags VkBufferUsageFlags; + typedef VkFlags VkBufferCreateFlags; + typedef VkFlags VkShaderStageFlags; + typedef VkFlags VkImageUsageFlags; + typedef VkFlags VkImageCreateFlags; + typedef VkFlags VkImageViewCreateFlags; + typedef VkFlags VkPipelineCreateFlags; + typedef VkFlags VkColorComponentFlags; + typedef VkFlags VkFenceCreateFlags; + typedef VkFlags VkSemaphoreCreateFlags; + typedef VkFlags VkFormatFeatureFlags; + typedef VkFlags VkQueryControlFlags; + typedef VkFlags VkQueryResultFlags; + typedef VkFlags VkShaderModuleCreateFlags; + typedef VkFlags VkEventCreateFlags; + typedef VkFlags VkCommandPoolCreateFlags; + typedef VkFlags VkCommandPoolResetFlags; + typedef VkFlags VkCommandBufferResetFlags; + typedef VkFlags VkCommandBufferUsageFlags; + typedef VkFlags VkQueryPipelineStatisticFlags; + typedef VkFlags VkMemoryMapFlags; + typedef VkFlags VkImageAspectFlags; + typedef VkFlags VkSparseMemoryBindFlags; + typedef VkFlags VkSparseImageFormatFlags; + typedef VkFlags VkSubpassDescriptionFlags; + typedef VkFlags VkPipelineStageFlags; + typedef VkFlags VkSampleCountFlags; + typedef VkFlags VkAttachmentDescriptionFlags; + typedef VkFlags VkStencilFaceFlags; + typedef VkFlags VkCullModeFlags; + typedef VkFlags VkDescriptorPoolCreateFlags; + typedef VkFlags VkDescriptorPoolResetFlags; + typedef VkFlags VkDependencyFlags; + typedef VkFlags VkSubgroupFeatureFlags; + typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNV; + typedef VkFlags VkIndirectStateFlagsNV; + typedef VkFlags VkGeometryFlagsKHR; + + typedef VkFlags VkGeometryInstanceFlagsKHR; + + typedef VkFlags VkBuildAccelerationStructureFlagsKHR; + + typedef VkFlags VkPrivateDataSlotCreateFlagsEXT; + typedef VkFlags VkAccelerationStructureCreateFlagsKHR; + typedef VkFlags VkDescriptorUpdateTemplateCreateFlags; + + typedef VkFlags VkPipelineCreationFeedbackFlagsEXT; + typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR; + typedef VkFlags VkAcquireProfilingLockFlagsKHR; + typedef VkFlags VkSemaphoreWaitFlags; + + typedef VkFlags VkPipelineCompilerControlFlagsAMD; + typedef VkFlags VkShaderCorePropertiesFlagsAMD; + typedef VkFlags VkDeviceDiagnosticsConfigFlagsNV; + typedef VkFlags VkRefreshObjectFlagsKHR; + typedef VkFlags64 VkAccessFlags2KHR; + typedef VkFlags64 VkPipelineStageFlags2KHR; + typedef VkFlags VkAccelerationStructureMotionInfoFlagsNV; + typedef VkFlags VkAccelerationStructureMotionInstanceFlagsNV; + typedef VkFlags64 VkFormatFeatureFlags2KHR; + typedef VkFlags VkRenderingFlagsKHR; + + WSI extensions + typedef VkFlags VkCompositeAlphaFlagsKHR; + typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; + typedef VkFlags VkSurfaceTransformFlagsKHR; + typedef VkFlags VkSwapchainCreateFlagsKHR; + typedef VkFlags VkDisplayModeCreateFlagsKHR; + typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; + typedef VkFlags VkAndroidSurfaceCreateFlagsKHR; + typedef VkFlags VkViSurfaceCreateFlagsNN; + typedef VkFlags VkWaylandSurfaceCreateFlagsKHR; + typedef VkFlags VkWin32SurfaceCreateFlagsKHR; + typedef VkFlags VkXlibSurfaceCreateFlagsKHR; + typedef VkFlags VkXcbSurfaceCreateFlagsKHR; + typedef VkFlags VkDirectFBSurfaceCreateFlagsEXT; + typedef VkFlags VkIOSSurfaceCreateFlagsMVK; + typedef VkFlags VkMacOSSurfaceCreateFlagsMVK; + typedef VkFlags VkMetalSurfaceCreateFlagsEXT; + typedef VkFlags VkImagePipeSurfaceCreateFlagsFUCHSIA; + typedef VkFlags VkStreamDescriptorSurfaceCreateFlagsGGP; + typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT; + typedef VkFlags VkScreenSurfaceCreateFlagsQNX; + typedef VkFlags VkPeerMemoryFeatureFlags; + + typedef VkFlags VkMemoryAllocateFlags; + + typedef VkFlags VkDeviceGroupPresentModeFlagsKHR; + + typedef VkFlags VkDebugReportFlagsEXT; + typedef VkFlags VkCommandPoolTrimFlags; + + typedef VkFlags VkExternalMemoryHandleTypeFlagsNV; + typedef VkFlags VkExternalMemoryFeatureFlagsNV; + typedef VkFlags VkExternalMemoryHandleTypeFlags; + + typedef VkFlags VkExternalMemoryFeatureFlags; + + typedef VkFlags VkExternalSemaphoreHandleTypeFlags; + + typedef VkFlags VkExternalSemaphoreFeatureFlags; + + typedef VkFlags VkSemaphoreImportFlags; + + typedef VkFlags VkExternalFenceHandleTypeFlags; + + typedef VkFlags VkExternalFenceFeatureFlags; + + typedef VkFlags VkFenceImportFlags; + + typedef VkFlags VkSurfaceCounterFlagsEXT; + typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV; + typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; + typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV; + typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV; + typedef VkFlags VkPipelineCoverageReductionStateCreateFlagsNV; + typedef VkFlags VkValidationCacheCreateFlagsEXT; + typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT; + typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT; + typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT; + typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT; + typedef VkFlags VkDeviceMemoryReportFlagsEXT; + typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT; + typedef VkFlags VkDescriptorBindingFlags; + + typedef VkFlags VkConditionalRenderingFlagsEXT; + typedef VkFlags VkResolveModeFlags; + + typedef VkFlags VkPipelineRasterizationStateStreamCreateFlagsEXT; + typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT; + typedef VkFlags VkSwapchainImageUsageFlagsANDROID; + typedef VkFlags VkToolPurposeFlagsEXT; + typedef VkFlags VkSubmitFlagsKHR; + typedef VkFlags VkImageFormatConstraintsFlagsFUCHSIA; + typedef VkFlags VkImageConstraintsInfoFlagsFUCHSIA; + + Video Core extension + typedef VkFlags VkVideoCodecOperationFlagsKHR; + typedef VkFlags VkVideoCapabilityFlagsKHR; + typedef VkFlags VkVideoSessionCreateFlagsKHR; + typedef VkFlags VkVideoBeginCodingFlagsKHR; + typedef VkFlags VkVideoEndCodingFlagsKHR; + typedef VkFlags VkVideoCodingQualityPresetFlagsKHR; + typedef VkFlags VkVideoCodingControlFlagsKHR; + + Video Decode Core extension + typedef VkFlags VkVideoDecodeFlagsKHR; + + Video Decode H.264 extension + typedef VkFlags VkVideoDecodeH264PictureLayoutFlagsEXT; + typedef VkFlags VkVideoDecodeH264CreateFlagsEXT; + + Video Decode H.265 extension + typedef VkFlags VkVideoDecodeH265CreateFlagsEXT; + + Video Encode Core extension + typedef VkFlags VkVideoEncodeFlagsKHR; + typedef VkFlags VkVideoEncodeRateControlFlagsKHR; + typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR; + typedef VkFlags VkVideoChromaSubsamplingFlagsKHR; + typedef VkFlags VkVideoComponentBitDepthFlagsKHR; + + Video Encode H.264 extension + typedef VkFlags VkVideoEncodeH264CapabilityFlagsEXT; + typedef VkFlags VkVideoEncodeH264InputModeFlagsEXT; + typedef VkFlags VkVideoEncodeH264OutputModeFlagsEXT; + typedef VkFlags VkVideoEncodeH264CreateFlagsEXT; + typedef VkFlags VkVideoEncodeH264RateControlStructureFlagsEXT; + + Video Encode H.265 extension + typedef VkFlags VkVideoEncodeH265CapabilityFlagsEXT; + typedef VkFlags VkVideoEncodeH265InputModeFlagsEXT; + typedef VkFlags VkVideoEncodeH265OutputModeFlagsEXT; + typedef VkFlags VkVideoEncodeH265CreateFlagsEXT; + typedef VkFlags VkVideoEncodeH265CtbSizeFlagsEXT; + typedef VkFlags VkVideoEncodeH265RateControlStructureFlagsEXT; + + Types which can be void pointers or class pointers, selected at compile time + VK_DEFINE_HANDLE(VkInstance) + VK_DEFINE_HANDLE(VkPhysicalDevice) + VK_DEFINE_HANDLE(VkDevice) + VK_DEFINE_HANDLE(VkQueue) + VK_DEFINE_HANDLE(VkCommandBuffer) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNV) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate) + + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion) + + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNV) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPerformanceConfigurationINTEL) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferCollectionFUCHSIA) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeferredOperationKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPrivateDataSlotEXT) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuModuleNVX) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuFunctionNVX) + + WSI extensions + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT) + + Video extensions + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionParametersKHR) + + Types generated from corresponding enums tags below + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Extensions + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + WSI extensions + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Enumerated types in the header, but not used by the API + + + + + + + + Video Core extensions + + + + + + + + + + Video Decode extensions + + + Video H.264 Decode extensions + + + Video H.265 Decode extensions + + Video Encode extensions + + + + + Video H.264 Encode extensions + + + + + + + Video H.265 Encode extensions + + + + + + The PFN_vk*Function types are used by VkAllocationCallbacks below + typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( + void* pUserData, + void* pOriginal, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( + void* pUserData, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + typedef void (VKAPI_PTR *PFN_vkFreeFunction)( + void* pUserData, + void* pMemory); + + The PFN_vkVoidFunction type are used by VkGet*ProcAddr below + typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); + + The PFN_vkDebugReportCallbackEXT type are used by the DEBUG_REPORT extension + typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)( + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage, + void* pUserData); + + The PFN_vkDebugUtilsMessengerCallbackEXT type are used by the VK_EXT_debug_utils extension + typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)( + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, + void* pUserData); + + The PFN_vkFaultCallbackFunction type is used by VKSC_VERSION_1_0 + typedef void (VKAPI_PTR *PFN_vkFaultCallbackFunction)( + VkBool32 unrecordedFaults, + uint32_t faultCount, + const VkFaultData* pFaults); + + The PFN_vkDeviceMemoryReportCallbackEXT type is used by the VK_EXT_device_memory_report extension + typedef void (VKAPI_PTR *PFN_vkDeviceMemoryReportCallbackEXT)( + const VkDeviceMemoryReportCallbackDataEXT* pCallbackData, + void* pUserData); + + Struct types + + VkStructureType sType + struct VkBaseOutStructure* pNext + + + VkStructureType sType + const struct VkBaseInStructure* pNext + + + int32_t x + int32_t y + + + int32_t x + int32_t y + int32_t z + + + uint32_t width + uint32_t height + + + uint32_t width + uint32_t height + uint32_t depth + + + float x + float y + float width + float height + float minDepth + float maxDepth + + + VkOffset2D offset + VkExtent2D extent + + + VkRect2D rect + uint32_t baseArrayLayer + uint32_t layerCount + + + VkComponentSwizzle r + VkComponentSwizzle g + VkComponentSwizzle b + VkComponentSwizzle a + + + uint32_t apiVersion + uint32_t driverVersion + uint32_t vendorID + uint32_t deviceID + VkPhysicalDeviceType deviceType + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE] + uint8_t pipelineCacheUUID[VK_UUID_SIZE] + VkPhysicalDeviceLimits limits + VkPhysicalDeviceSparseProperties sparseProperties + + + char extensionName[VK_MAX_EXTENSION_NAME_SIZE]extension name + uint32_t specVersionversion of the extension specification implemented + + + char layerName[VK_MAX_EXTENSION_NAME_SIZE]layer name + uint32_t specVersionversion of the layer specification implemented + uint32_t implementationVersionbuild or release version of the layer's library + char description[VK_MAX_DESCRIPTION_SIZE]Free-form description of the layer + + + VkStructureType sType + const void* pNext + const char* pApplicationName + uint32_t applicationVersion + const char* pEngineName + uint32_t engineVersion + uint32_t apiVersion + + + void* pUserData + PFN_vkAllocationFunction pfnAllocation + PFN_vkReallocationFunction pfnReallocation + PFN_vkFreeFunction pfnFree + PFN_vkInternalAllocationNotification pfnInternalAllocation + PFN_vkInternalFreeNotification pfnInternalFree + + + VkStructureType sType + const void* pNext + VkDeviceQueueCreateFlags flags + uint32_t queueFamilyIndex + uint32_t queueCount + const float* pQueuePriorities + + + VkStructureType sType + const void* pNext + VkDeviceCreateFlags flags + uint32_t queueCreateInfoCount + const VkDeviceQueueCreateInfo* pQueueCreateInfos + uint32_t enabledLayerCount + const char* const* ppEnabledLayerNamesOrdered list of layer names to be enabled + uint32_t enabledExtensionCount + const char* const* ppEnabledExtensionNames + const VkPhysicalDeviceFeatures* pEnabledFeatures + + + VkStructureType sType + const void* pNext + VkInstanceCreateFlags flags + const VkApplicationInfo* pApplicationInfo + uint32_t enabledLayerCount + const char* const* ppEnabledLayerNamesOrdered list of layer names to be enabled + uint32_t enabledExtensionCount + const char* const* ppEnabledExtensionNamesExtension names to be enabled + + + VkQueueFlags queueFlagsQueue flags + uint32_t queueCount + uint32_t timestampValidBits + VkExtent3D minImageTransferGranularityMinimum alignment requirement for image transfers + + + uint32_t memoryTypeCount + VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES] + uint32_t memoryHeapCount + VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS] + + + VkStructureType sType + const void* pNext + VkDeviceSize allocationSizeSize of memory allocation + uint32_t memoryTypeIndexIndex of the of the memory type to allocate from + + + VkDeviceSize sizeSpecified in bytes + VkDeviceSize alignmentSpecified in bytes + uint32_t memoryTypeBitsBitmask of the allowed memory type indices into memoryTypes[] for this object + + + VkImageAspectFlags aspectMask + VkExtent3D imageGranularity + VkSparseImageFormatFlags flags + + + VkSparseImageFormatProperties formatProperties + uint32_t imageMipTailFirstLod + VkDeviceSize imageMipTailSizeSpecified in bytes, must be a multiple of sparse block size in bytes / alignment + VkDeviceSize imageMipTailOffsetSpecified in bytes, must be a multiple of sparse block size in bytes / alignment + VkDeviceSize imageMipTailStrideSpecified in bytes, must be a multiple of sparse block size in bytes / alignment + + + VkMemoryPropertyFlags propertyFlagsMemory properties of this memory type + uint32_t heapIndexIndex of the memory heap allocations of this memory type are taken from + + + VkDeviceSize sizeAvailable memory in the heap + VkMemoryHeapFlags flagsFlags for the heap + + + VkStructureType sType + const void* pNext + VkDeviceMemory memoryMapped memory object + VkDeviceSize offsetOffset within the memory object where the range starts + VkDeviceSize sizeSize of the range within the memory object + + + VkFormatFeatureFlags linearTilingFeaturesFormat features in case of linear tiling + VkFormatFeatureFlags optimalTilingFeaturesFormat features in case of optimal tiling + VkFormatFeatureFlags bufferFeaturesFormat features supported by buffers + + + VkExtent3D maxExtentmax image dimensions for this resource type + uint32_t maxMipLevelsmax number of mipmap levels for this resource type + uint32_t maxArrayLayersmax array size for this resource type + VkSampleCountFlags sampleCountssupported sample counts for this resource type + VkDeviceSize maxResourceSizemax size (in bytes) of this resource type + + + VkBuffer bufferBuffer used for this descriptor slot. + VkDeviceSize offsetBase offset from buffer start in bytes to update in the descriptor set. + VkDeviceSize rangeSize in bytes of the buffer resource for this descriptor update. + + + VkSampler samplerSampler to write to the descriptor in case it is a SAMPLER or COMBINED_IMAGE_SAMPLER descriptor. Ignored otherwise. + VkImageView imageViewImage view to write to the descriptor in case it is a SAMPLED_IMAGE, STORAGE_IMAGE, COMBINED_IMAGE_SAMPLER, or INPUT_ATTACHMENT descriptor. Ignored otherwise. + VkImageLayout imageLayoutLayout the image is expected to be in when accessed using this descriptor (only used if imageView is not VK_NULL_HANDLE). + + + VkStructureType sType + const void* pNext + VkDescriptorSet dstSetDestination descriptor set + uint32_t dstBindingBinding within the destination descriptor set to write + uint32_t dstArrayElementArray element within the destination binding to write + uint32_t descriptorCountNumber of descriptors to write (determines the size of the array pointed by pDescriptors) + VkDescriptorType descriptorTypeDescriptor type to write (determines which members of the array pointed by pDescriptors are going to be used) + const VkDescriptorImageInfo* pImageInfoSampler, image view, and layout for SAMPLER, COMBINED_IMAGE_SAMPLER, {SAMPLED,STORAGE}_IMAGE, and INPUT_ATTACHMENT descriptor types. + const VkDescriptorBufferInfo* pBufferInfoRaw buffer, size, and offset for {UNIFORM,STORAGE}_BUFFER[_DYNAMIC] descriptor types. + const VkBufferView* pTexelBufferViewBuffer view to write to the descriptor for {UNIFORM,STORAGE}_TEXEL_BUFFER descriptor types. + + + VkStructureType sType + const void* pNext + VkDescriptorSet srcSetSource descriptor set + uint32_t srcBindingBinding within the source descriptor set to copy from + uint32_t srcArrayElementArray element within the source binding to copy from + VkDescriptorSet dstSetDestination descriptor set + uint32_t dstBindingBinding within the destination descriptor set to copy to + uint32_t dstArrayElementArray element within the destination binding to copy to + uint32_t descriptorCountNumber of descriptors to write (determines the size of the array pointed by pDescriptors) + + + VkStructureType sType + const void* pNext + VkBufferCreateFlags flagsBuffer creation flags + VkDeviceSize sizeSpecified in bytes + VkBufferUsageFlags usageBuffer usage flags + VkSharingMode sharingMode + uint32_t queueFamilyIndexCount + const uint32_t* pQueueFamilyIndices + + + VkStructureType sType + const void* pNext + VkBufferViewCreateFlagsflags + VkBuffer buffer + VkFormat formatOptionally specifies format of elements + VkDeviceSize offsetSpecified in bytes + VkDeviceSize rangeView size specified in bytes + + + VkImageAspectFlags aspectMask + uint32_t mipLevel + uint32_t arrayLayer + + + VkImageAspectFlags aspectMask + uint32_t mipLevel + uint32_t baseArrayLayer + uint32_t layerCount + + + VkImageAspectFlags aspectMask + uint32_t baseMipLevel + uint32_t levelCount + uint32_t baseArrayLayer + uint32_t layerCount + + + VkStructureType sType + const void* pNext + VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize + VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize + + + VkStructureType sType + const void* pNext + VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize + VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize + uint32_t srcQueueFamilyIndexQueue family to transition ownership from + uint32_t dstQueueFamilyIndexQueue family to transition ownership to + VkBuffer bufferBuffer to sync + VkDeviceSize offsetOffset within the buffer to sync + VkDeviceSize sizeAmount of bytes to sync + + + VkStructureType sType + const void* pNext + VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize + VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize + VkImageLayout oldLayoutCurrent layout of the image + VkImageLayout newLayoutNew layout to transition the image to + uint32_t srcQueueFamilyIndexQueue family to transition ownership from + uint32_t dstQueueFamilyIndexQueue family to transition ownership to + VkImage imageImage to sync + VkImageSubresourceRange subresourceRangeSubresource range to sync + + + VkStructureType sType + const void* pNext + VkImageCreateFlags flagsImage creation flags + VkImageType imageType + VkFormat format + VkExtent3D extent + uint32_t mipLevels + uint32_t arrayLayers + VkSampleCountFlagBits samples + VkImageTiling tiling + VkImageUsageFlags usageImage usage flags + VkSharingMode sharingModeCross-queue-family sharing mode + uint32_t queueFamilyIndexCountNumber of queue families to share across + const uint32_t* pQueueFamilyIndicesArray of queue family indices to share across + VkImageLayout initialLayoutInitial image layout for all subresources + + + VkDeviceSize offsetSpecified in bytes + VkDeviceSize sizeSpecified in bytes + VkDeviceSize rowPitchSpecified in bytes + VkDeviceSize arrayPitchSpecified in bytes + VkDeviceSize depthPitchSpecified in bytes + + + VkStructureType sType + const void* pNext + VkImageViewCreateFlags flags + VkImage image + VkImageViewType viewType + VkFormat format + VkComponentMapping components + VkImageSubresourceRange subresourceRange + + + VkDeviceSize srcOffsetSpecified in bytes + VkDeviceSize dstOffsetSpecified in bytes + VkDeviceSize sizeSpecified in bytes + + + VkDeviceSize resourceOffsetSpecified in bytes + VkDeviceSize sizeSpecified in bytes + VkDeviceMemory memory + VkDeviceSize memoryOffsetSpecified in bytes + VkSparseMemoryBindFlagsflags + + + VkImageSubresource subresource + VkOffset3D offset + VkExtent3D extent + VkDeviceMemory memory + VkDeviceSize memoryOffsetSpecified in bytes + VkSparseMemoryBindFlagsflags + + + VkBuffer buffer + uint32_t bindCount + const VkSparseMemoryBind* pBinds + + + VkImage image + uint32_t bindCount + const VkSparseMemoryBind* pBinds + + + VkImage image + uint32_t bindCount + const VkSparseImageMemoryBind* pBinds + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreCount + const VkSemaphore* pWaitSemaphores + uint32_t bufferBindCount + const VkSparseBufferMemoryBindInfo* pBufferBinds + uint32_t imageOpaqueBindCount + const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds + uint32_t imageBindCount + const VkSparseImageMemoryBindInfo* pImageBinds + uint32_t signalSemaphoreCount + const VkSemaphore* pSignalSemaphores + + + VkImageSubresourceLayers srcSubresource + VkOffset3D srcOffsetSpecified in pixels for both compressed and uncompressed images + VkImageSubresourceLayers dstSubresource + VkOffset3D dstOffsetSpecified in pixels for both compressed and uncompressed images + VkExtent3D extentSpecified in pixels for both compressed and uncompressed images + + + VkImageSubresourceLayers srcSubresource + VkOffset3D srcOffsets[2]Specified in pixels for both compressed and uncompressed images + VkImageSubresourceLayers dstSubresource + VkOffset3D dstOffsets[2]Specified in pixels for both compressed and uncompressed images + + + VkDeviceSize bufferOffsetSpecified in bytes + uint32_t bufferRowLengthSpecified in texels + uint32_t bufferImageHeight + VkImageSubresourceLayers imageSubresource + VkOffset3D imageOffsetSpecified in pixels for both compressed and uncompressed images + VkExtent3D imageExtentSpecified in pixels for both compressed and uncompressed images + + + VkImageSubresourceLayers srcSubresource + VkOffset3D srcOffset + VkImageSubresourceLayers dstSubresource + VkOffset3D dstOffset + VkExtent3D extent + + + VkStructureType sType + const void* pNext + VkShaderModuleCreateFlags flags + size_t codeSizeSpecified in bytes + const uint32_t* pCodeBinary code of size codeSize + + + uint32_t bindingBinding number for this entry + VkDescriptorType descriptorTypeType of the descriptors in this binding + uint32_t descriptorCountNumber of descriptors in this binding + VkShaderStageFlags stageFlagsShader stages this binding is visible to + const VkSampler* pImmutableSamplersImmutable samplers (used if descriptor type is SAMPLER or COMBINED_IMAGE_SAMPLER, is either NULL or contains count number of elements) + + + VkStructureType sType + const void* pNext + VkDescriptorSetLayoutCreateFlags flags + uint32_t bindingCountNumber of bindings in the descriptor set layout + const VkDescriptorSetLayoutBinding* pBindingsArray of descriptor set layout bindings + + + VkDescriptorType type + uint32_t descriptorCount + + + VkStructureType sType + const void* pNext + VkDescriptorPoolCreateFlags flags + uint32_t maxSets + uint32_t poolSizeCount + const VkDescriptorPoolSize* pPoolSizes + + + VkStructureType sType + const void* pNext + VkDescriptorPool descriptorPool + uint32_t descriptorSetCount + const VkDescriptorSetLayout* pSetLayouts + + + uint32_t constantIDThe SpecConstant ID specified in the BIL + uint32_t offsetOffset of the value in the data block + size_t sizeSize in bytes of the SpecConstant + + + uint32_t mapEntryCountNumber of entries in the map + const VkSpecializationMapEntry* pMapEntriesArray of map entries + size_t dataSizeSize in bytes of pData + const void* pDataPointer to SpecConstant data + + + VkStructureType sType + const void* pNext + VkPipelineShaderStageCreateFlags flags + VkShaderStageFlagBits stageShader stage + VkShaderModule moduleModule containing entry point + VkShaderModule moduleModule containing entry point + const char* pNameNull-terminated entry point name + const char* pNameNull-terminated entry point name + const VkSpecializationInfo* pSpecializationInfo + + + VkStructureType sType + const void* pNext + VkPipelineCreateFlags flagsPipeline creation flags + VkPipelineShaderStageCreateInfo stage + VkPipelineLayout layoutInterface layout of the pipeline + VkPipeline basePipelineHandleIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of + int32_t basePipelineIndexIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of + + + uint32_t bindingVertex buffer binding id + uint32_t strideDistance between vertices in bytes (0 = no advancement) + VkVertexInputRate inputRateThe rate at which the vertex data is consumed + + + uint32_t locationlocation of the shader vertex attrib + uint32_t bindingVertex buffer binding id + VkFormat formatformat of source data + uint32_t offsetOffset of first element in bytes from base of vertex + + + VkStructureType sType + const void* pNext + VkPipelineVertexInputStateCreateFlags flags + uint32_t vertexBindingDescriptionCountnumber of bindings + const VkVertexInputBindingDescription* pVertexBindingDescriptions + uint32_t vertexAttributeDescriptionCountnumber of attributes + const VkVertexInputAttributeDescription* pVertexAttributeDescriptions + + + VkStructureType sType + const void* pNext + VkPipelineInputAssemblyStateCreateFlags flags + VkPrimitiveTopology topology + VkBool32 primitiveRestartEnable + + + VkStructureType sType + const void* pNext + VkPipelineTessellationStateCreateFlags flags + uint32_t patchControlPoints + + + VkStructureType sType + const void* pNext + VkPipelineViewportStateCreateFlags flags + uint32_t viewportCount + const VkViewport* pViewports + uint32_t scissorCount + const VkRect2D* pScissors + + + VkStructureType sType + const void* pNext + VkPipelineRasterizationStateCreateFlags flags + VkBool32 depthClampEnable + VkBool32 rasterizerDiscardEnable + VkPolygonMode polygonModeoptional (GL45) + VkCullModeFlags cullMode + VkFrontFace frontFace + VkBool32 depthBiasEnable + float depthBiasConstantFactor + float depthBiasClamp + float depthBiasSlopeFactor + float lineWidth + + + VkStructureType sType + const void* pNext + VkPipelineMultisampleStateCreateFlags flags + VkSampleCountFlagBits rasterizationSamplesNumber of samples used for rasterization + VkBool32 sampleShadingEnableoptional (GL45) + float minSampleShadingoptional (GL45) + const VkSampleMask* pSampleMaskArray of sampleMask words + VkBool32 alphaToCoverageEnable + VkBool32 alphaToOneEnable + + + VkBool32 blendEnable + VkBlendFactor srcColorBlendFactor + VkBlendFactor dstColorBlendFactor + VkBlendOp colorBlendOp + VkBlendFactor srcAlphaBlendFactor + VkBlendFactor dstAlphaBlendFactor + VkBlendOp alphaBlendOp + VkColorComponentFlags colorWriteMask + + + VkStructureType sType + const void* pNext + VkPipelineColorBlendStateCreateFlags flags + VkBool32 logicOpEnable + VkLogicOp logicOp + uint32_t attachmentCount# of pAttachments + const VkPipelineColorBlendAttachmentState* pAttachments + float blendConstants[4] + + + VkStructureType sType + const void* pNext + VkPipelineDynamicStateCreateFlags flags + uint32_t dynamicStateCount + const VkDynamicState* pDynamicStates + + + VkStencilOp failOp + VkStencilOp passOp + VkStencilOp depthFailOp + VkCompareOp compareOp + uint32_t compareMask + uint32_t writeMask + uint32_t reference + + + VkStructureType sType + const void* pNext + VkPipelineDepthStencilStateCreateFlags flags + VkBool32 depthTestEnable + VkBool32 depthWriteEnable + VkCompareOp depthCompareOp + VkBool32 depthBoundsTestEnableoptional (depth_bounds_test) + VkBool32 stencilTestEnable + VkStencilOpState front + VkStencilOpState back + float minDepthBounds + float maxDepthBounds + + + VkStructureType sType + const void* pNext + VkPipelineCreateFlags flagsPipeline creation flags + uint32_t stageCount + uint32_t stageCount + const VkPipelineShaderStageCreateInfo* pStagesOne entry for each active shader stage + const VkPipelineVertexInputStateCreateInfo* pVertexInputState + const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState + const VkPipelineTessellationStateCreateInfo* pTessellationState + const VkPipelineViewportStateCreateInfo* pViewportState + const VkPipelineRasterizationStateCreateInfo* pRasterizationState + const VkPipelineMultisampleStateCreateInfo* pMultisampleState + const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState + const VkPipelineColorBlendStateCreateInfo* pColorBlendState + const VkPipelineDynamicStateCreateInfo* pDynamicState + VkPipelineLayout layoutInterface layout of the pipeline + VkRenderPass renderPass + uint32_t subpass + VkPipeline basePipelineHandleIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of + int32_t basePipelineIndexIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of + + + VkStructureType sType + const void* pNext + VkPipelineCacheCreateFlags flags + size_t initialDataSizeSize of initial data to populate cache, in bytes + size_t initialDataSizeSize of initial data to populate cache, in bytes + const void* pInitialDataInitial data to populate cache + + + The fields in this structure are non-normative since structure packing is implementation-defined in C. The specification defines the normative layout. + uint32_t headerSize + VkPipelineCacheHeaderVersion headerVersion + uint32_t vendorID + uint32_t deviceID + uint8_t pipelineCacheUUID[VK_UUID_SIZE] + + + The fields in this structure are non-normative since structure packing is implementation-defined in C. The specification defines the normative layout. + uint64_t codeSize + uint64_t codeOffset + + + The fields in this structure are non-normative since structure packing is implementation-defined in C. The specification defines the normative layout. + uint8_t pipelineIdentifier[VK_UUID_SIZE] + uint64_t pipelineMemorySize + uint64_t jsonSize + uint64_t jsonOffset + uint32_t stageIndexCount + uint32_t stageIndexStride + uint64_t stageIndexOffset + + + The fields in this structure are non-normative since structure packing is implementation-defined in C. The specification defines the normative layout. + VkPipelineCacheHeaderVersionOne headerVersionOne + VkPipelineCacheValidationVersion validationVersion + uint32_t implementationData + uint32_t pipelineIndexCount + uint32_t pipelineIndexStride + uint64_t pipelineIndexOffset + + + VkShaderStageFlags stageFlagsWhich stages use the range + uint32_t offsetStart of the range, in bytes + uint32_t sizeSize of the range, in bytes + + + VkStructureType sType + const void* pNext + VkPipelineLayoutCreateFlags flags + uint32_t setLayoutCountNumber of descriptor sets interfaced by the pipeline + const VkDescriptorSetLayout* pSetLayoutsArray of setCount number of descriptor set layout objects defining the layout of the + uint32_t pushConstantRangeCountNumber of push-constant ranges used by the pipeline + const VkPushConstantRange* pPushConstantRangesArray of pushConstantRangeCount number of ranges used by various shader stages + + + VkStructureType sType + const void* pNext + VkSamplerCreateFlags flags + VkFilter magFilterFilter mode for magnification + VkFilter minFilterFilter mode for minifiation + VkSamplerMipmapMode mipmapModeMipmap selection mode + VkSamplerAddressMode addressModeU + VkSamplerAddressMode addressModeV + VkSamplerAddressMode addressModeW + float mipLodBias + VkBool32 anisotropyEnable + float maxAnisotropy + VkBool32 compareEnable + VkCompareOp compareOp + float minLod + float maxLod + VkBorderColor borderColor + VkBool32 unnormalizedCoordinates + + + VkStructureType sType + const void* pNext + VkCommandPoolCreateFlags flagsCommand pool creation flags + uint32_t queueFamilyIndex + + + VkStructureType sType + const void* pNext + VkCommandPool commandPool + VkCommandBufferLevel level + uint32_t commandBufferCount + + + VkStructureType sType + const void* pNext + VkRenderPass renderPassRender pass for secondary command buffers + uint32_t subpass + VkFramebuffer framebufferFramebuffer for secondary command buffers + VkBool32 occlusionQueryEnableWhether this secondary command buffer may be executed during an occlusion query + VkQueryControlFlags queryFlagsQuery flags used by this secondary command buffer, if executed during an occlusion query + VkQueryPipelineStatisticFlags pipelineStatisticsPipeline statistics that may be counted for this secondary command buffer + + + VkStructureType sType + const void* pNext + VkCommandBufferUsageFlags flagsCommand buffer usage flags + const VkCommandBufferInheritanceInfo* pInheritanceInfoPointer to inheritance info for secondary command buffers + + + VkStructureType sType + const void* pNext + VkRenderPass renderPass + VkFramebuffer framebuffer + VkRect2D renderArea + uint32_t clearValueCount + const VkClearValue* pClearValues + + + float float32[4] + int32_t int32[4] + uint32_t uint32[4] + + + float depth + uint32_t stencil + + + VkClearColorValue color + VkClearDepthStencilValue depthStencil + + + VkImageAspectFlags aspectMask + uint32_t colorAttachment + VkClearValue clearValue + + + VkAttachmentDescriptionFlags flags + VkFormat format + VkSampleCountFlagBits samples + VkAttachmentLoadOp loadOpLoad operation for color or depth data + VkAttachmentStoreOp storeOpStore operation for color or depth data + VkAttachmentLoadOp stencilLoadOpLoad operation for stencil data + VkAttachmentStoreOp stencilStoreOpStore operation for stencil data + VkImageLayout initialLayout + VkImageLayout finalLayout + + + uint32_t attachment + VkImageLayout layout + + + VkSubpassDescriptionFlags flags + VkPipelineBindPoint pipelineBindPointMust be VK_PIPELINE_BIND_POINT_GRAPHICS for now + uint32_t inputAttachmentCount + const VkAttachmentReference* pInputAttachments + uint32_t colorAttachmentCount + const VkAttachmentReference* pColorAttachments + const VkAttachmentReference* pResolveAttachments + const VkAttachmentReference* pDepthStencilAttachment + uint32_t preserveAttachmentCount + const uint32_t* pPreserveAttachments + + + uint32_t srcSubpass + uint32_t dstSubpass + VkPipelineStageFlags srcStageMask + VkPipelineStageFlags dstStageMask + VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize + VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize + VkDependencyFlags dependencyFlags + + + VkStructureType sType + const void* pNext + VkRenderPassCreateFlags flags + uint32_t attachmentCount + const VkAttachmentDescription* pAttachments + uint32_t subpassCount + const VkSubpassDescription* pSubpasses + uint32_t dependencyCount + const VkSubpassDependency* pDependencies + + + VkStructureType sType + const void* pNext + VkEventCreateFlags flagsEvent creation flags + + + VkStructureType sType + const void* pNext + VkFenceCreateFlags flagsFence creation flags + + + VkBool32 robustBufferAccessout of bounds buffer accesses are well defined + VkBool32 fullDrawIndexUint32full 32-bit range of indices for indexed draw calls + VkBool32 imageCubeArrayimage views which are arrays of cube maps + VkBool32 independentBlendblending operations are controlled per-attachment + VkBool32 geometryShadergeometry stage + VkBool32 tessellationShadertessellation control and evaluation stage + VkBool32 sampleRateShadingper-sample shading and interpolation + VkBool32 dualSrcBlendblend operations which take two sources + VkBool32 logicOplogic operations + VkBool32 multiDrawIndirectmulti draw indirect + VkBool32 drawIndirectFirstInstanceindirect drawing can use non-zero firstInstance + VkBool32 depthClampdepth clamping + VkBool32 depthBiasClampdepth bias clamping + VkBool32 fillModeNonSolidpoint and wireframe fill modes + VkBool32 depthBoundsdepth bounds test + VkBool32 wideLineslines with width greater than 1 + VkBool32 largePointspoints with size greater than 1 + VkBool32 alphaToOnethe fragment alpha component can be forced to maximum representable alpha value + VkBool32 multiViewportviewport arrays + VkBool32 samplerAnisotropyanisotropic sampler filtering + VkBool32 textureCompressionETC2ETC texture compression formats + VkBool32 textureCompressionASTC_LDRASTC LDR texture compression formats + VkBool32 textureCompressionBCBC1-7 texture compressed formats + VkBool32 occlusionQueryPreciseprecise occlusion queries returning actual sample counts + VkBool32 pipelineStatisticsQuerypipeline statistics query + VkBool32 vertexPipelineStoresAndAtomicsstores and atomic ops on storage buffers and images are supported in vertex, tessellation, and geometry stages + VkBool32 fragmentStoresAndAtomicsstores and atomic ops on storage buffers and images are supported in the fragment stage + VkBool32 shaderTessellationAndGeometryPointSizetessellation and geometry stages can export point size + VkBool32 shaderImageGatherExtendedimage gather with run-time values and independent offsets + VkBool32 shaderStorageImageExtendedFormatsthe extended set of formats can be used for storage images + VkBool32 shaderStorageImageMultisamplemultisample images can be used for storage images + VkBool32 shaderStorageImageReadWithoutFormatread from storage image does not require format qualifier + VkBool32 shaderStorageImageWriteWithoutFormatwrite to storage image does not require format qualifier + VkBool32 shaderUniformBufferArrayDynamicIndexingarrays of uniform buffers can be accessed with dynamically uniform indices + VkBool32 shaderSampledImageArrayDynamicIndexingarrays of sampled images can be accessed with dynamically uniform indices + VkBool32 shaderStorageBufferArrayDynamicIndexingarrays of storage buffers can be accessed with dynamically uniform indices + VkBool32 shaderStorageImageArrayDynamicIndexingarrays of storage images can be accessed with dynamically uniform indices + VkBool32 shaderClipDistanceclip distance in shaders + VkBool32 shaderCullDistancecull distance in shaders + VkBool32 shaderFloat6464-bit floats (doubles) in shaders + VkBool32 shaderInt6464-bit integers in shaders + VkBool32 shaderInt1616-bit integers in shaders + VkBool32 shaderResourceResidencyshader can use texture operations that return resource residency information (requires sparseNonResident support) + VkBool32 shaderResourceMinLodshader can use texture operations that specify minimum resource LOD + VkBool32 sparseBindingSparse resources support: Resource memory can be managed at opaque page level rather than object level + VkBool32 sparseResidencyBufferSparse resources support: GPU can access partially resident buffers + VkBool32 sparseResidencyImage2DSparse resources support: GPU can access partially resident 2D (non-MSAA non-depth/stencil) images + VkBool32 sparseResidencyImage3DSparse resources support: GPU can access partially resident 3D images + VkBool32 sparseResidency2SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 2 samples + VkBool32 sparseResidency4SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 4 samples + VkBool32 sparseResidency8SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 8 samples + VkBool32 sparseResidency16SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 16 samples + VkBool32 sparseResidencyAliasedSparse resources support: GPU can correctly access data aliased into multiple locations (opt-in) + VkBool32 variableMultisampleRatemultisample rate must be the same for all pipelines in a subpass + VkBool32 inheritedQueriesQueries may be inherited from primary to secondary command buffers + + + VkBool32 residencyStandard2DBlockShapeSparse resources support: GPU will access all 2D (single sample) sparse resources using the standard sparse image block shapes (based on pixel format) + VkBool32 residencyStandard2DMultisampleBlockShapeSparse resources support: GPU will access all 2D (multisample) sparse resources using the standard sparse image block shapes (based on pixel format) + VkBool32 residencyStandard3DBlockShapeSparse resources support: GPU will access all 3D sparse resources using the standard sparse image block shapes (based on pixel format) + VkBool32 residencyAlignedMipSizeSparse resources support: Images with mip level dimensions that are NOT a multiple of the sparse image block dimensions will be placed in the mip tail + VkBool32 residencyNonResidentStrictSparse resources support: GPU can consistently access non-resident regions of a resource, all reads return as if data is 0, writes are discarded + + + resource maximum sizes + uint32_t maxImageDimension1Dmax 1D image dimension + uint32_t maxImageDimension2Dmax 2D image dimension + uint32_t maxImageDimension3Dmax 3D image dimension + uint32_t maxImageDimensionCubemax cubemap image dimension + uint32_t maxImageArrayLayersmax layers for image arrays + uint32_t maxTexelBufferElementsmax texel buffer size (fstexels) + uint32_t maxUniformBufferRangemax uniform buffer range (bytes) + uint32_t maxStorageBufferRangemax storage buffer range (bytes) + uint32_t maxPushConstantsSizemax size of the push constants pool (bytes) + memory limits + uint32_t maxMemoryAllocationCountmax number of device memory allocations supported + uint32_t maxSamplerAllocationCountmax number of samplers that can be allocated on a device + VkDeviceSize bufferImageGranularityGranularity (in bytes) at which buffers and images can be bound to adjacent memory for simultaneous usage + VkDeviceSize sparseAddressSpaceSizeTotal address space available for sparse allocations (bytes) + descriptor set limits + uint32_t maxBoundDescriptorSetsmax number of descriptors sets that can be bound to a pipeline + uint32_t maxPerStageDescriptorSamplersmax number of samplers allowed per-stage in a descriptor set + uint32_t maxPerStageDescriptorUniformBuffersmax number of uniform buffers allowed per-stage in a descriptor set + uint32_t maxPerStageDescriptorStorageBuffersmax number of storage buffers allowed per-stage in a descriptor set + uint32_t maxPerStageDescriptorSampledImagesmax number of sampled images allowed per-stage in a descriptor set + uint32_t maxPerStageDescriptorStorageImagesmax number of storage images allowed per-stage in a descriptor set + uint32_t maxPerStageDescriptorInputAttachmentsmax number of input attachments allowed per-stage in a descriptor set + uint32_t maxPerStageResourcesmax number of resources allowed by a single stage + uint32_t maxDescriptorSetSamplersmax number of samplers allowed in all stages in a descriptor set + uint32_t maxDescriptorSetUniformBuffersmax number of uniform buffers allowed in all stages in a descriptor set + uint32_t maxDescriptorSetUniformBuffersDynamicmax number of dynamic uniform buffers allowed in all stages in a descriptor set + uint32_t maxDescriptorSetStorageBuffersmax number of storage buffers allowed in all stages in a descriptor set + uint32_t maxDescriptorSetStorageBuffersDynamicmax number of dynamic storage buffers allowed in all stages in a descriptor set + uint32_t maxDescriptorSetSampledImagesmax number of sampled images allowed in all stages in a descriptor set + uint32_t maxDescriptorSetStorageImagesmax number of storage images allowed in all stages in a descriptor set + uint32_t maxDescriptorSetInputAttachmentsmax number of input attachments allowed in all stages in a descriptor set + vertex stage limits + uint32_t maxVertexInputAttributesmax number of vertex input attribute slots + uint32_t maxVertexInputBindingsmax number of vertex input binding slots + uint32_t maxVertexInputAttributeOffsetmax vertex input attribute offset added to vertex buffer offset + uint32_t maxVertexInputBindingStridemax vertex input binding stride + uint32_t maxVertexOutputComponentsmax number of output components written by vertex shader + tessellation control stage limits + uint32_t maxTessellationGenerationLevelmax level supported by tessellation primitive generator + uint32_t maxTessellationPatchSizemax patch size (vertices) + uint32_t maxTessellationControlPerVertexInputComponentsmax number of input components per-vertex in TCS + uint32_t maxTessellationControlPerVertexOutputComponentsmax number of output components per-vertex in TCS + uint32_t maxTessellationControlPerPatchOutputComponentsmax number of output components per-patch in TCS + uint32_t maxTessellationControlTotalOutputComponentsmax total number of per-vertex and per-patch output components in TCS + tessellation evaluation stage limits + uint32_t maxTessellationEvaluationInputComponentsmax number of input components per vertex in TES + uint32_t maxTessellationEvaluationOutputComponentsmax number of output components per vertex in TES + geometry stage limits + uint32_t maxGeometryShaderInvocationsmax invocation count supported in geometry shader + uint32_t maxGeometryInputComponentsmax number of input components read in geometry stage + uint32_t maxGeometryOutputComponentsmax number of output components written in geometry stage + uint32_t maxGeometryOutputVerticesmax number of vertices that can be emitted in geometry stage + uint32_t maxGeometryTotalOutputComponentsmax total number of components (all vertices) written in geometry stage + fragment stage limits + uint32_t maxFragmentInputComponentsmax number of input components read in fragment stage + uint32_t maxFragmentOutputAttachmentsmax number of output attachments written in fragment stage + uint32_t maxFragmentDualSrcAttachmentsmax number of output attachments written when using dual source blending + uint32_t maxFragmentCombinedOutputResourcesmax total number of storage buffers, storage images and output buffers + compute stage limits + uint32_t maxComputeSharedMemorySizemax total storage size of work group local storage (bytes) + uint32_t maxComputeWorkGroupCount[3]max num of compute work groups that may be dispatched by a single command (x,y,z) + uint32_t maxComputeWorkGroupInvocationsmax total compute invocations in a single local work group + uint32_t maxComputeWorkGroupSize[3]max local size of a compute work group (x,y,z) + uint32_t subPixelPrecisionBitsnumber bits of subpixel precision in screen x and y + uint32_t subTexelPrecisionBitsnumber bits of precision for selecting texel weights + uint32_t mipmapPrecisionBitsnumber bits of precision for selecting mipmap weights + uint32_t maxDrawIndexedIndexValuemax index value for indexed draw calls (for 32-bit indices) + uint32_t maxDrawIndirectCountmax draw count for indirect drawing calls + float maxSamplerLodBiasmax absolute sampler LOD bias + float maxSamplerAnisotropymax degree of sampler anisotropy + uint32_t maxViewportsmax number of active viewports + uint32_t maxViewportDimensions[2]max viewport dimensions (x,y) + float viewportBoundsRange[2]viewport bounds range (min,max) + uint32_t viewportSubPixelBitsnumber bits of subpixel precision for viewport + size_t minMemoryMapAlignmentmin required alignment of pointers returned by MapMemory (bytes) + VkDeviceSize minTexelBufferOffsetAlignmentmin required alignment for texel buffer offsets (bytes) + VkDeviceSize minUniformBufferOffsetAlignmentmin required alignment for uniform buffer sizes and offsets (bytes) + VkDeviceSize minStorageBufferOffsetAlignmentmin required alignment for storage buffer offsets (bytes) + int32_t minTexelOffsetmin texel offset for OpTextureSampleOffset + uint32_t maxTexelOffsetmax texel offset for OpTextureSampleOffset + int32_t minTexelGatherOffsetmin texel offset for OpTextureGatherOffset + uint32_t maxTexelGatherOffsetmax texel offset for OpTextureGatherOffset + float minInterpolationOffsetfurthest negative offset for interpolateAtOffset + float maxInterpolationOffsetfurthest positive offset for interpolateAtOffset + uint32_t subPixelInterpolationOffsetBitsnumber of subpixel bits for interpolateAtOffset + uint32_t maxFramebufferWidthmax width for a framebuffer + uint32_t maxFramebufferHeightmax height for a framebuffer + uint32_t maxFramebufferLayersmax layer count for a layered framebuffer + VkSampleCountFlags framebufferColorSampleCountssupported color sample counts for a framebuffer + VkSampleCountFlags framebufferDepthSampleCountssupported depth sample counts for a framebuffer + VkSampleCountFlags framebufferStencilSampleCountssupported stencil sample counts for a framebuffer + VkSampleCountFlags framebufferNoAttachmentsSampleCountssupported sample counts for a subpass which uses no attachments + uint32_t maxColorAttachmentsmax number of color attachments per subpass + VkSampleCountFlags sampledImageColorSampleCountssupported color sample counts for a non-integer sampled image + VkSampleCountFlags sampledImageIntegerSampleCountssupported sample counts for an integer image + VkSampleCountFlags sampledImageDepthSampleCountssupported depth sample counts for a sampled image + VkSampleCountFlags sampledImageStencilSampleCountssupported stencil sample counts for a sampled image + VkSampleCountFlags storageImageSampleCountssupported sample counts for a storage image + uint32_t maxSampleMaskWordsmax number of sample mask words + VkBool32 timestampComputeAndGraphicstimestamps on graphics and compute queues + float timestampPeriodnumber of nanoseconds it takes for timestamp query value to increment by 1 + uint32_t maxClipDistancesmax number of clip distances + uint32_t maxCullDistancesmax number of cull distances + uint32_t maxCombinedClipAndCullDistancesmax combined number of user clipping + uint32_t discreteQueuePrioritiesdistinct queue priorities available + float pointSizeRange[2]range (min,max) of supported point sizes + float lineWidthRange[2]range (min,max) of supported line widths + float pointSizeGranularitygranularity of supported point sizes + float lineWidthGranularitygranularity of supported line widths + VkBool32 strictLinesline rasterization follows preferred rules + VkBool32 standardSampleLocationssupports standard sample locations for all supported sample counts + VkDeviceSize optimalBufferCopyOffsetAlignmentoptimal offset of buffer copies + VkDeviceSize optimalBufferCopyRowPitchAlignmentoptimal pitch of buffer copies + VkDeviceSize nonCoherentAtomSizeminimum size and alignment for non-coherent host-mapped device memory access + + + VkStructureType sType + const void* pNext + VkSemaphoreCreateFlags flagsSemaphore creation flags + + + VkStructureType sType + const void* pNext + VkQueryPoolCreateFlags flags + VkQueryType queryType + uint32_t queryCount + VkQueryPipelineStatisticFlags pipelineStatisticsOptional + + + VkStructureType sType + const void* pNext + VkFramebufferCreateFlags flags + VkRenderPass renderPass + uint32_t attachmentCount + const VkImageView* pAttachments + uint32_t width + uint32_t height + uint32_t layers + + + uint32_t vertexCount + uint32_t instanceCount + uint32_t firstVertex + uint32_t firstInstance + + + uint32_t indexCount + uint32_t instanceCount + uint32_t firstIndex + int32_t vertexOffset + uint32_t firstInstance + + + uint32_t x + uint32_t y + uint32_t z + + + uint32_t firstVertex + uint32_t vertexCount + + + uint32_t firstIndex + uint32_t indexCount + int32_t vertexOffset + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreCount + const VkSemaphore* pWaitSemaphores + const VkPipelineStageFlags* pWaitDstStageMask + uint32_t commandBufferCount + const VkCommandBuffer* pCommandBuffers + uint32_t signalSemaphoreCount + const VkSemaphore* pSignalSemaphores + + WSI extensions + + VkDisplayKHR displayHandle of the display object + const char* displayNameName of the display + VkExtent2D physicalDimensionsIn millimeters? + VkExtent2D physicalResolutionMax resolution for CRT? + VkSurfaceTransformFlagsKHR supportedTransformsone or more bits from VkSurfaceTransformFlagsKHR + VkBool32 planeReorderPossibleVK_TRUE if the overlay plane's z-order can be changed on this display. + VkBool32 persistentContentVK_TRUE if this is a "smart" display that supports self-refresh/internal buffering. + + + VkDisplayKHR currentDisplayDisplay the plane is currently associated with. Will be VK_NULL_HANDLE if the plane is not in use. + uint32_t currentStackIndexCurrent z-order of the plane. + + + VkExtent2D visibleRegionVisible scanout region. + uint32_t refreshRateNumber of times per second the display is updated. + + + VkDisplayModeKHR displayModeHandle of this display mode. + VkDisplayModeParametersKHR parametersThe parameters this mode uses. + + + VkStructureType sType + const void* pNext + VkDisplayModeCreateFlagsKHR flags + VkDisplayModeParametersKHR parametersThe parameters this mode uses. + + + VkDisplayPlaneAlphaFlagsKHR supportedAlphaTypes of alpha blending supported, if any. + VkOffset2D minSrcPositionDoes the plane have any position and extent restrictions? + VkOffset2D maxSrcPosition + VkExtent2D minSrcExtent + VkExtent2D maxSrcExtent + VkOffset2D minDstPosition + VkOffset2D maxDstPosition + VkExtent2D minDstExtent + VkExtent2D maxDstExtent + + + VkStructureType sType + const void* pNext + VkDisplaySurfaceCreateFlagsKHR flags + VkDisplayModeKHR displayModeThe mode to use when displaying this surface + uint32_t planeIndexThe plane on which this surface appears. Must be between 0 and the value returned by vkGetPhysicalDeviceDisplayPlanePropertiesKHR() in pPropertyCount. + uint32_t planeStackIndexThe z-order of the plane. + VkSurfaceTransformFlagBitsKHR transformTransform to apply to the images as part of the scanout operation + float globalAlphaGlobal alpha value. Must be between 0 and 1, inclusive. Ignored if alphaMode is not VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR + VkDisplayPlaneAlphaFlagBitsKHR alphaModeWhat type of alpha blending to use. Must be a bit from vkGetDisplayPlanePropertiesKHR::supportedAlpha. + VkExtent2D imageExtentsize of the images to use with this surface + + + VkStructureType sType + const void* pNext + VkRect2D srcRectRectangle within the presentable image to read pixel data from when presenting to the display. + VkRect2D dstRectRectangle within the current display mode's visible region to display srcRectangle in. + VkBool32 persistentFor smart displays, use buffered mode. If the display properties member "persistentMode" is VK_FALSE, this member must always be VK_FALSE. + + + uint32_t minImageCountSupported minimum number of images for the surface + uint32_t maxImageCountSupported maximum number of images for the surface, 0 for unlimited + VkExtent2D currentExtentCurrent image width and height for the surface, (0, 0) if undefined + VkExtent2D minImageExtentSupported minimum image width and height for the surface + VkExtent2D maxImageExtentSupported maximum image width and height for the surface + uint32_t maxImageArrayLayersSupported maximum number of image layers for the surface + VkSurfaceTransformFlagsKHR supportedTransforms1 or more bits representing the transforms supported + VkSurfaceTransformFlagBitsKHR currentTransformThe surface's current transform relative to the device's natural orientation + VkCompositeAlphaFlagsKHR supportedCompositeAlpha1 or more bits representing the alpha compositing modes supported + VkImageUsageFlags supportedUsageFlagsSupported image usage flags for the surface + + + VkStructureType sType + const void* pNext + VkAndroidSurfaceCreateFlagsKHR flags + struct ANativeWindow* window + + + VkStructureType sType + const void* pNext + VkViSurfaceCreateFlagsNN flags + void* window + + + VkStructureType sType + const void* pNext + VkWaylandSurfaceCreateFlagsKHR flags + struct wl_display* display + struct wl_surface* surface + + + VkStructureType sType + const void* pNext + VkWin32SurfaceCreateFlagsKHR flags + HINSTANCE hinstance + HWND hwnd + + + VkStructureType sType + const void* pNext + VkXlibSurfaceCreateFlagsKHR flags + Display* dpy + Window window + + + VkStructureType sType + const void* pNext + VkXcbSurfaceCreateFlagsKHR flags + xcb_connection_t* connection + xcb_window_t window + + + VkStructureType sType + const void* pNext + VkDirectFBSurfaceCreateFlagsEXT flags + IDirectFB* dfb + IDirectFBSurface* surface + + + VkStructureType sType + const void* pNext + VkImagePipeSurfaceCreateFlagsFUCHSIA flags + zx_handle_t imagePipeHandle + + + VkStructureType sType + const void* pNext + VkStreamDescriptorSurfaceCreateFlagsGGP flags + GgpStreamDescriptor streamDescriptor + + + VkStructureType sType + const void* pNext + VkScreenSurfaceCreateFlagsQNX flags + struct _screen_context* context + struct _screen_window* window + + + VkFormat formatSupported pair of rendering format + VkColorSpaceKHR colorSpaceand color space for the surface + + + VkStructureType sType + const void* pNext + VkSwapchainCreateFlagsKHR flags + VkSurfaceKHR surfaceThe swapchain's target surface + uint32_t minImageCountMinimum number of presentation images the application needs + VkFormat imageFormatFormat of the presentation images + VkColorSpaceKHR imageColorSpaceColorspace of the presentation images + VkExtent2D imageExtentDimensions of the presentation images + uint32_t imageArrayLayersDetermines the number of views for multiview/stereo presentation + VkImageUsageFlags imageUsageBits indicating how the presentation images will be used + VkSharingMode imageSharingModeSharing mode used for the presentation images + uint32_t queueFamilyIndexCountNumber of queue families having access to the images in case of concurrent sharing mode + const uint32_t* pQueueFamilyIndicesArray of queue family indices having access to the images in case of concurrent sharing mode + VkSurfaceTransformFlagBitsKHR preTransformThe transform, relative to the device's natural orientation, applied to the image content prior to presentation + VkCompositeAlphaFlagBitsKHR compositeAlphaThe alpha blending mode used when compositing this surface with other surfaces in the window system + VkPresentModeKHR presentModeWhich presentation mode to use for presents on this swap chain + VkBool32 clippedSpecifies whether presentable images may be affected by window clip regions + VkSwapchainKHR oldSwapchainExisting swap chain to replace, if any + VkSwapchainKHR oldSwapchainExisting swap chain to replace, if any + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreCountNumber of semaphores to wait for before presenting + const VkSemaphore* pWaitSemaphoresSemaphores to wait for before presenting + uint32_t swapchainCountNumber of swapchains to present in this call + const VkSwapchainKHR* pSwapchainsSwapchains to present an image from + const uint32_t* pImageIndicesIndices of which presentable images to present + VkResult* pResultsOptional (i.e. if non-NULL) VkResult for each swapchain + + + VkStructureType sType + const void* pNext + VkDebugReportFlagsEXT flagsIndicates which events call this callback + PFN_vkDebugReportCallbackEXT pfnCallbackFunction pointer of a callback function + void* pUserDataUser data provided to callback function + + + VkStructureType sTypeMust be VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT + const void* pNext + uint32_t disabledValidationCheckCountNumber of validation checks to disable + const VkValidationCheckEXT* pDisabledValidationChecksValidation checks to disable + + + VkStructureType sTypeMust be VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT + const void* pNext + uint32_t enabledValidationFeatureCountNumber of validation features to enable + const VkValidationFeatureEnableEXT* pEnabledValidationFeaturesValidation features to enable + uint32_t disabledValidationFeatureCountNumber of validation features to disable + const VkValidationFeatureDisableEXT* pDisabledValidationFeaturesValidation features to disable + + + VkStructureType sType + const void* pNext + uint32_t vendorID + uint32_t deviceID + uint32_t key + uint64_t value + + + VkStructureType sType + const void* pNext + VkRasterizationOrderAMD rasterizationOrderRasterization order to use for the pipeline + + + VkStructureType sType + const void* pNext + VkDebugReportObjectTypeEXT objectTypeThe type of the object + uint64_t objectThe handle of the object, cast to uint64_t + const char* pObjectNameName to apply to the object + + + VkStructureType sType + const void* pNext + VkDebugReportObjectTypeEXT objectTypeThe type of the object + uint64_t objectThe handle of the object, cast to uint64_t + uint64_t tagNameThe name of the tag to set on the object + size_t tagSizeThe length in bytes of the tag data + const void* pTagTag data to attach to the object + + + VkStructureType sType + const void* pNext + const char* pMarkerNameName of the debug marker + float color[4]Optional color for debug marker + + + VkStructureType sType + const void* pNext + VkBool32 dedicatedAllocationWhether this image uses a dedicated allocation + + + VkStructureType sType + const void* pNext + VkBool32 dedicatedAllocationWhether this buffer uses a dedicated allocation + + + VkStructureType sType + const void* pNext + VkImage imageImage that this allocation will be bound to + VkBuffer bufferBuffer that this allocation will be bound to + + + VkImageFormatProperties imageFormatProperties + VkExternalMemoryFeatureFlagsNV externalMemoryFeatures + VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes + VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagsNV handleTypes + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagsNV handleTypes + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagsNV handleType + HANDLE handle + + + VkStructureType sType + const void* pNext + const SECURITY_ATTRIBUTES* pAttributes + DWORD dwAccess + + + VkStructureType sType + const void* pNext + uint32_t acquireCount + const VkDeviceMemory* pAcquireSyncs + const uint64_t* pAcquireKeys + const uint32_t* pAcquireTimeoutMilliseconds + uint32_t releaseCount + const VkDeviceMemory* pReleaseSyncs + const uint64_t* pReleaseKeys + + + VkStructureTypesType + void* pNext + VkBool32 deviceGeneratedCommands + + + VkStructureType sType + const void* pNext + uint32_t privateDataSlotRequestCount + + + VkStructureType sType + const void* pNext + VkPrivateDataSlotCreateFlagsEXT flags + + + VkStructureType sType + void* pNext + VkBool32 privateData + + + VkStructureType sType + void* pNext + uint32_t maxGraphicsShaderGroupCount + uint32_t maxIndirectSequenceCount + uint32_t maxIndirectCommandsTokenCount + uint32_t maxIndirectCommandsStreamCount + uint32_t maxIndirectCommandsTokenOffset + uint32_t maxIndirectCommandsStreamStride + uint32_t minSequencesCountBufferOffsetAlignment + uint32_t minSequencesIndexBufferOffsetAlignment + uint32_t minIndirectCommandsBufferOffsetAlignment + + + VkStructureType sType + void* pNext + uint32_t maxMultiDrawCount + + + VkStructureType sType + const void* pNext + uint32_t stageCount + const VkPipelineShaderStageCreateInfo* pStages + const VkPipelineVertexInputStateCreateInfo* pVertexInputState + const VkPipelineTessellationStateCreateInfo* pTessellationState + + + VkStructureType sType + const void* pNext + uint32_t groupCount + const VkGraphicsShaderGroupCreateInfoNV* pGroups + uint32_t pipelineCount + const VkPipeline* pPipelines + + + uint32_t groupIndex + + + VkDeviceAddress bufferAddress + uint32_t size + VkIndexType indexType + + + VkDeviceAddress bufferAddress + uint32_t size + uint32_t stride + + + uint32_t data + + + VkBuffer buffer + VkDeviceSize offset + + + VkStructureType sType + const void* pNext + VkIndirectCommandsTokenTypeNV tokenType + uint32_t stream + uint32_t offset + uint32_t vertexBindingUnit + VkBool32 vertexDynamicStride + VkPipelineLayout pushconstantPipelineLayout + VkShaderStageFlags pushconstantShaderStageFlags + uint32_t pushconstantOffset + uint32_t pushconstantSize + VkIndirectStateFlagsNV indirectStateFlags + uint32_t indexTypeCount + const VkIndexType* pIndexTypes + const uint32_t* pIndexTypeValues + + + VkStructureType sType + const void* pNext + VkIndirectCommandsLayoutUsageFlagsNV flags + VkPipelineBindPoint pipelineBindPoint + uint32_t tokenCount + const VkIndirectCommandsLayoutTokenNV* pTokens + uint32_t streamCount + const uint32_t* pStreamStrides + + + VkStructureType sType + const void* pNext + VkPipelineBindPoint pipelineBindPoint + VkPipeline pipeline + VkIndirectCommandsLayoutNV indirectCommandsLayout + uint32_t streamCount + const VkIndirectCommandsStreamNV* pStreams + uint32_t sequencesCount + VkBuffer preprocessBuffer + VkDeviceSize preprocessOffset + VkDeviceSize preprocessSize + VkBuffer sequencesCountBuffer + VkDeviceSize sequencesCountOffset + VkBuffer sequencesIndexBuffer + VkDeviceSize sequencesIndexOffset + + + VkStructureType sType + const void* pNext + VkPipelineBindPoint pipelineBindPoint + VkPipeline pipeline + VkIndirectCommandsLayoutNV indirectCommandsLayout + uint32_t maxSequencesCount + + + VkStructureType sType + void* pNext + VkPhysicalDeviceFeatures features + + + + VkStructureType sType + void* pNext + VkPhysicalDeviceProperties properties + + + + VkStructureType sType + void* pNext + VkFormatProperties formatProperties + + + + VkStructureType sType + void* pNext + VkImageFormatProperties imageFormatProperties + + + + VkStructureType sType + const void* pNext + VkFormat format + VkImageType type + VkImageTiling tiling + VkImageUsageFlags usage + VkImageCreateFlags flags + + + + VkStructureType sType + void* pNext + VkQueueFamilyProperties queueFamilyProperties + + + + VkStructureType sType + void* pNext + VkPhysicalDeviceMemoryProperties memoryProperties + + + + VkStructureType sType + void* pNext + VkSparseImageFormatProperties properties + + + + VkStructureType sType + const void* pNext + VkFormat format + VkImageType type + VkSampleCountFlagBits samples + VkImageUsageFlags usage + VkImageTiling tiling + + + + VkStructureType sType + void* pNext + uint32_t maxPushDescriptors + + + uint8_t major + uint8_t minor + uint8_t subminor + uint8_t patch + + + + VkStructureType sType + void* pNext + VkDriverId driverID + char driverName[VK_MAX_DRIVER_NAME_SIZE] + char driverInfo[VK_MAX_DRIVER_INFO_SIZE] + VkConformanceVersion conformanceVersion + + + + VkStructureType sType + const void* pNext + uint32_t swapchainCountCopy of VkPresentInfoKHR::swapchainCount + const VkPresentRegionKHR* pRegionsThe regions that have changed + + + uint32_t rectangleCountNumber of rectangles in pRectangles + const VkRectLayerKHR* pRectanglesArray of rectangles that have changed in a swapchain's image(s) + + + VkOffset2D offsetupper-left corner of a rectangle that has not changed, in pixels of a presentation images + VkExtent2D extentDimensions of a rectangle that has not changed, in pixels of a presentation images + uint32_t layerLayer of a swapchain's image(s), for stereoscopic-3D images + + + VkStructureType sType + void* pNext + VkBool32 variablePointersStorageBuffer + VkBool32 variablePointers + + + + + + VkExternalMemoryFeatureFlags externalMemoryFeatures + VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes + VkExternalMemoryHandleTypeFlags compatibleHandleTypes + + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagBits handleType + + + + VkStructureType sType + void* pNext + VkExternalMemoryProperties externalMemoryProperties + + + + VkStructureType sType + const void* pNext + VkBufferCreateFlags flags + VkBufferUsageFlags usage + VkExternalMemoryHandleTypeFlagBits handleType + + + + VkStructureType sType + void* pNext + VkExternalMemoryProperties externalMemoryProperties + + + + VkStructureType sType + void* pNext + uint8_t deviceUUID[VK_UUID_SIZE] + uint8_t driverUUID[VK_UUID_SIZE] + uint8_t deviceLUID[VK_LUID_SIZE] + uint32_t deviceNodeMask + VkBool32 deviceLUIDValid + + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlags handleTypes + + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlags handleTypes + + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlags handleTypes + + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagBits handleType + HANDLE handle + LPCWSTR name + + + VkStructureType sType + const void* pNext + const SECURITY_ATTRIBUTES* pAttributes + DWORD dwAccess + LPCWSTR name + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagBits handleType + zx_handle_t handle + + + VkStructureType sType + void* pNext + uint32_t memoryTypeBits + + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + VkExternalMemoryHandleTypeFlagBits handleType + + + VkStructureType sType + void* pNext + uint32_t memoryTypeBits + + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + VkExternalMemoryHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagBits handleType + int fd + + + VkStructureType sType + void* pNext + uint32_t memoryTypeBits + + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + VkExternalMemoryHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + uint32_t acquireCount + const VkDeviceMemory* pAcquireSyncs + const uint64_t* pAcquireKeys + const uint32_t* pAcquireTimeouts + uint32_t releaseCount + const VkDeviceMemory* pReleaseSyncs + const uint64_t* pReleaseKeys + + + VkStructureType sType + const void* pNext + VkExternalSemaphoreHandleTypeFlagBits handleType + + + + VkStructureType sType + void* pNext + VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes + VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes + VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures + + + + VkStructureType sType + const void* pNext + VkExternalSemaphoreHandleTypeFlags handleTypes + + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkSemaphoreImportFlags flags + VkExternalSemaphoreHandleTypeFlagBits handleType + HANDLE handle + LPCWSTR name + + + VkStructureType sType + const void* pNext + const SECURITY_ATTRIBUTES* pAttributes + DWORD dwAccess + LPCWSTR name + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreValuesCount + const uint64_t* pWaitSemaphoreValues + uint32_t signalSemaphoreValuesCount + const uint64_t* pSignalSemaphoreValues + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkExternalSemaphoreHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkSemaphoreImportFlags flags + VkExternalSemaphoreHandleTypeFlagBits handleType + int fd + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkExternalSemaphoreHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkSemaphoreImportFlags flags + VkExternalSemaphoreHandleTypeFlagBits handleType + zx_handle_t zirconHandle + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkExternalSemaphoreHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + VkExternalFenceHandleTypeFlagBits handleType + + + + VkStructureType sType + void* pNext + VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes + VkExternalFenceHandleTypeFlags compatibleHandleTypes + VkExternalFenceFeatureFlags externalFenceFeatures + + + + VkStructureType sType + const void* pNext + VkExternalFenceHandleTypeFlags handleTypes + + + + VkStructureType sType + const void* pNext + VkFence fence + VkFenceImportFlags flags + VkExternalFenceHandleTypeFlagBits handleType + HANDLE handle + LPCWSTR name + + + VkStructureType sType + const void* pNext + const SECURITY_ATTRIBUTES* pAttributes + DWORD dwAccess + LPCWSTR name + + + VkStructureType sType + const void* pNext + VkFence fence + VkExternalFenceHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + VkFence fence + VkFenceImportFlags flags + VkExternalFenceHandleTypeFlagBits handleType + int fd + + + VkStructureType sType + const void* pNext + VkFence fence + VkExternalFenceHandleTypeFlagBits handleType + + + VkStructureType sType + void* pNext + VkBool32 multiviewMultiple views in a renderpass + VkBool32 multiviewGeometryShaderMultiple views in a renderpass w/ geometry shader + VkBool32 multiviewTessellationShaderMultiple views in a renderpass w/ tessellation shader + + + + VkStructureType sType + void* pNext + uint32_t maxMultiviewViewCountmax number of views in a subpass + uint32_t maxMultiviewInstanceIndexmax instance index for a draw in a multiview subpass + + + + VkStructureType sType + const void* pNext + uint32_t subpassCount + const uint32_t* pViewMasks + uint32_t dependencyCount + const int32_t* pViewOffsets + uint32_t correlationMaskCount + const uint32_t* pCorrelationMasks + + + + VkStructureType sType + void* pNext + uint32_t minImageCountSupported minimum number of images for the surface + uint32_t maxImageCountSupported maximum number of images for the surface, 0 for unlimited + VkExtent2D currentExtentCurrent image width and height for the surface, (0, 0) if undefined + VkExtent2D minImageExtentSupported minimum image width and height for the surface + VkExtent2D maxImageExtentSupported maximum image width and height for the surface + uint32_t maxImageArrayLayersSupported maximum number of image layers for the surface + VkSurfaceTransformFlagsKHR supportedTransforms1 or more bits representing the transforms supported + VkSurfaceTransformFlagBitsKHR currentTransformThe surface's current transform relative to the device's natural orientation + VkCompositeAlphaFlagsKHR supportedCompositeAlpha1 or more bits representing the alpha compositing modes supported + VkImageUsageFlags supportedUsageFlagsSupported image usage flags for the surface + VkSurfaceCounterFlagsEXT supportedSurfaceCounters + + + VkStructureType sType + const void* pNext + VkDisplayPowerStateEXT powerState + + + VkStructureType sType + const void* pNext + VkDeviceEventTypeEXT deviceEvent + + + VkStructureType sType + const void* pNext + VkDisplayEventTypeEXT displayEvent + + + VkStructureType sType + const void* pNext + VkSurfaceCounterFlagsEXT surfaceCounters + + + VkStructureType sType + void* pNext + uint32_t physicalDeviceCount + VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE] + VkBool32 subsetAllocation + + + + VkStructureType sType + const void* pNext + VkMemoryAllocateFlags flags + uint32_t deviceMask + + + + VkStructureType sType + const void* pNext + VkBuffer buffer + VkDeviceMemory memory + VkDeviceSize memoryOffset + + + + VkStructureType sType + const void* pNext + uint32_t deviceIndexCount + const uint32_t* pDeviceIndices + + + + VkStructureType sType + const void* pNext + VkImage image + VkDeviceMemory memory + VkDeviceSize memoryOffset + + + + VkStructureType sType + const void* pNext + uint32_t deviceIndexCount + const uint32_t* pDeviceIndices + uint32_t splitInstanceBindRegionCount + const VkRect2D* pSplitInstanceBindRegions + + + + VkStructureType sType + const void* pNext + uint32_t deviceMask + uint32_t deviceRenderAreaCount + const VkRect2D* pDeviceRenderAreas + + + + VkStructureType sType + const void* pNext + uint32_t deviceMask + + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreCount + const uint32_t* pWaitSemaphoreDeviceIndices + uint32_t commandBufferCount + const uint32_t* pCommandBufferDeviceMasks + uint32_t signalSemaphoreCount + const uint32_t* pSignalSemaphoreDeviceIndices + + + + VkStructureType sType + const void* pNext + uint32_t resourceDeviceIndex + uint32_t memoryDeviceIndex + + + + VkStructureType sType + void* pNext + uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE] + VkDeviceGroupPresentModeFlagsKHR modes + + + VkStructureType sType + const void* pNext + VkSwapchainKHR swapchain + + + VkStructureType sType + const void* pNext + VkSwapchainKHR swapchain + uint32_t imageIndex + + + VkStructureType sType + const void* pNext + VkSwapchainKHR swapchain + uint64_t timeout + VkSemaphore semaphore + VkFence fence + uint32_t deviceMask + + + VkStructureType sType + const void* pNext + uint32_t swapchainCount + const uint32_t* pDeviceMasks + VkDeviceGroupPresentModeFlagBitsKHR mode + + + VkStructureType sType + const void* pNext + uint32_t physicalDeviceCount + const VkPhysicalDevice* pPhysicalDevices + + + + VkStructureType sType + const void* pNext + VkDeviceGroupPresentModeFlagsKHR modes + + + uint32_t dstBindingBinding within the destination descriptor set to write + uint32_t dstArrayElementArray element within the destination binding to write + uint32_t descriptorCountNumber of descriptors to write + VkDescriptorType descriptorTypeDescriptor type to write + size_t offsetOffset into pData where the descriptors to update are stored + size_t strideStride between two descriptors in pData when writing more than one descriptor + + + + VkStructureType sType + const void* pNext + VkDescriptorUpdateTemplateCreateFlags flags + uint32_t descriptorUpdateEntryCountNumber of descriptor update entries to use for the update template + const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntriesDescriptor update entries for the template + VkDescriptorUpdateTemplateType templateType + VkDescriptorSetLayout descriptorSetLayout + VkPipelineBindPoint pipelineBindPoint + VkPipelineLayoutpipelineLayoutIf used for push descriptors, this is the only allowed layout + uint32_t set + + + + float x + float y + + + VkStructureType sType + void* pNext + VkBool32 presentIdPresent ID in VkPresentInfoKHR + + + VkStructureType sType + const void* pNext + uint32_t swapchainCountCopy of VkPresentInfoKHR::swapchainCount + const uint64_t* pPresentIdsPresent ID values for each swapchain + + + VkStructureType sType + void* pNext + VkBool32 presentWaitvkWaitForPresentKHR is supported + + + Display primary in chromaticity coordinates + VkStructureType sType + const void* pNext + From SMPTE 2086 + VkXYColorEXT displayPrimaryRedDisplay primary's Red + VkXYColorEXT displayPrimaryGreenDisplay primary's Green + VkXYColorEXT displayPrimaryBlueDisplay primary's Blue + VkXYColorEXT whitePointDisplay primary's Blue + float maxLuminanceDisplay maximum luminance + float minLuminanceDisplay minimum luminance + From CTA 861.3 + float maxContentLightLevelContent maximum luminance + float maxFrameAverageLightLevel + + + VkStructureType sType + void* pNext + VkBool32 localDimmingSupport + + + VkStructureType sType + const void* pNext + VkBool32 localDimmingEnable + + + uint64_t refreshDurationNumber of nanoseconds from the start of one refresh cycle to the next + + + uint32_t presentIDApplication-provided identifier, previously given to vkQueuePresentKHR + uint64_t desiredPresentTimeEarliest time an image should have been presented, previously given to vkQueuePresentKHR + uint64_t actualPresentTimeTime the image was actually displayed + uint64_t earliestPresentTimeEarliest time the image could have been displayed + uint64_t presentMarginHow early vkQueuePresentKHR was processed vs. how soon it needed to be and make earliestPresentTime + + + VkStructureType sType + const void* pNext + uint32_t swapchainCountCopy of VkPresentInfoKHR::swapchainCount + const VkPresentTimeGOOGLE* pTimesThe earliest times to present images + + + uint32_t presentIDApplication-provided identifier + uint64_t desiredPresentTimeEarliest time an image should be presented + + + VkStructureType sType + const void* pNext + VkIOSSurfaceCreateFlagsMVK flags + const void* pView + + + VkStructureType sType + const void* pNext + VkMacOSSurfaceCreateFlagsMVK flags + const void* pView + + + VkStructureType sType + const void* pNext + VkMetalSurfaceCreateFlagsEXT flags + const CAMetalLayer* pLayer + + + float xcoeff + float ycoeff + + + VkStructureType sType + const void* pNext + VkBool32 viewportWScalingEnable + uint32_t viewportCount + const VkViewportWScalingNV* pViewportWScalings + + + VkViewportCoordinateSwizzleNV x + VkViewportCoordinateSwizzleNV y + VkViewportCoordinateSwizzleNV z + VkViewportCoordinateSwizzleNV w + + + VkStructureType sType + const void* pNext + VkPipelineViewportSwizzleStateCreateFlagsNV flags + uint32_t viewportCount + const VkViewportSwizzleNV* pViewportSwizzles + + + VkStructureType sType + void* pNext + uint32_t maxDiscardRectanglesmax number of active discard rectangles + + + VkStructureType sType + const void* pNext + VkPipelineDiscardRectangleStateCreateFlagsEXT flags + VkDiscardRectangleModeEXT discardRectangleMode + uint32_t discardRectangleCount + const VkRect2D* pDiscardRectangles + + + VkStructureType sType + void* pNext + VkBool32 perViewPositionAllComponents + + + uint32_t subpass + uint32_t inputAttachmentIndex + VkImageAspectFlags aspectMask + + + + VkStructureType sType + const void* pNext + uint32_t aspectReferenceCount + const VkInputAttachmentAspectReference* pAspectReferences + + + + VkStructureType sType + const void* pNext + VkSurfaceKHR surface + + + VkStructureType sType + void* pNext + VkSurfaceCapabilitiesKHR surfaceCapabilities + + + VkStructureType sType + void* pNext + VkSurfaceFormatKHR surfaceFormat + + + VkStructureType sType + void* pNext + VkDisplayPropertiesKHR displayProperties + + + VkStructureType sType + void* pNext + VkDisplayPlanePropertiesKHR displayPlaneProperties + + + VkStructureType sType + void* pNext + VkDisplayModePropertiesKHR displayModeProperties + + + VkStructureType sType + const void* pNext + VkDisplayModeKHR mode + uint32_t planeIndex + + + VkStructureType sType + void* pNext + VkDisplayPlaneCapabilitiesKHR capabilities + + + VkStructureType sType + void* pNext + VkImageUsageFlags sharedPresentSupportedUsageFlagsSupported image usage flags if swapchain created using a shared present mode + + + VkStructureType sType + void* pNext + VkBool32 storageBuffer16BitAccess16-bit integer/floating-point variables supported in BufferBlock + VkBool32 uniformAndStorageBuffer16BitAccess16-bit integer/floating-point variables supported in BufferBlock and Block + VkBool32 storagePushConstant1616-bit integer/floating-point variables supported in PushConstant + VkBool32 storageInputOutput1616-bit integer/floating-point variables supported in shader inputs and outputs + + + + VkStructureType sType + void* pNext + uint32_t subgroupSizeThe size of a subgroup for this queue. + VkShaderStageFlags supportedStagesBitfield of what shader stages support subgroup operations + VkSubgroupFeatureFlags supportedOperationsBitfield of what subgroup operations are supported. + VkBool32 quadOperationsInAllStagesFlag to specify whether quad operations are available in all stages. + + + VkStructureType sType + void* pNext + VkBool32 shaderSubgroupExtendedTypesFlag to specify whether subgroup operations with extended types are supported + + + + VkStructureType sType + const void* pNext + VkBuffer buffer + + + + VkStructureType sType + const void* pNext + const VkBufferCreateInfo* pCreateInfo + + + VkStructureType sType + const void* pNext + VkImage image + + + + VkStructureType sType + const void* pNext + VkImage image + + + + VkStructureType sType + const void* pNext + const VkImageCreateInfo* pCreateInfo + VkImageAspectFlagBits planeAspect + + + VkStructureType sType + void* pNext + VkMemoryRequirements memoryRequirements + + + + VkStructureType sType + void* pNext + VkSparseImageMemoryRequirements memoryRequirements + + + + VkStructureType sType + void* pNext + VkPointClippingBehavior pointClippingBehavior + + + + VkStructureType sType + void* pNext + VkBool32 prefersDedicatedAllocation + VkBool32 requiresDedicatedAllocation + + + + VkStructureType sType + const void* pNext + VkImage imageImage that this allocation will be bound to + VkBuffer bufferBuffer that this allocation will be bound to + + + + VkStructureType sType + const void* pNext + VkImageUsageFlags usage + + + + VkStructureType sType + const void* pNext + VkTessellationDomainOrigin domainOrigin + + + + VkStructureType sType + const void* pNext + VkSamplerYcbcrConversion conversion + + + + VkStructureType sType + const void* pNext + VkFormat format + VkSamplerYcbcrModelConversion ycbcrModel + VkSamplerYcbcrRange ycbcrRange + VkComponentMapping components + VkChromaLocation xChromaOffset + VkChromaLocation yChromaOffset + VkFilter chromaFilter + VkBool32 forceExplicitReconstruction + + + + VkStructureType sType + const void* pNext + VkImageAspectFlagBits planeAspect + + + + VkStructureType sType + const void* pNext + VkImageAspectFlagBits planeAspect + + + + VkStructureType sType + void* pNext + VkBool32 samplerYcbcrConversionSampler color conversion supported + + + + VkStructureType sType + void* pNext + uint32_t combinedImageSamplerDescriptorCount + + + + VkStructureType sType + void* pNext + VkBool32 supportsTextureGatherLODBiasAMD + + + VkStructureType sType + const void* pNext + VkBuffer buffer + VkDeviceSize offset + VkConditionalRenderingFlagsEXT flags + + + VkStructureType sType + const void* pNext + VkBool32 protectedSubmitSubmit protected command buffers + + + VkStructureType sType + void* pNext + VkBool32 protectedMemory + + + VkStructureType sType + void* pNext + VkBool32 protectedNoFault + + + VkStructureType sType + const void* pNext + VkDeviceQueueCreateFlags flags + uint32_t queueFamilyIndex + uint32_t queueIndex + + + VkStructureType sType + const void* pNext + VkPipelineCoverageToColorStateCreateFlagsNV flags + VkBool32 coverageToColorEnable + uint32_t coverageToColorLocation + + + VkStructureType sType + void* pNext + VkBool32 filterMinmaxSingleComponentFormats + VkBool32 filterMinmaxImageComponentMapping + + + + float x + float y + + + VkStructureType sType + const void* pNext + VkSampleCountFlagBits sampleLocationsPerPixel + VkExtent2D sampleLocationGridSize + uint32_t sampleLocationsCount + const VkSampleLocationEXT* pSampleLocations + + + uint32_t attachmentIndex + VkSampleLocationsInfoEXT sampleLocationsInfo + + + uint32_t subpassIndex + VkSampleLocationsInfoEXT sampleLocationsInfo + + + VkStructureType sType + const void* pNext + uint32_t attachmentInitialSampleLocationsCount + const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations + uint32_t postSubpassSampleLocationsCount + const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations + + + VkStructureType sType + const void* pNext + VkBool32 sampleLocationsEnable + VkSampleLocationsInfoEXT sampleLocationsInfo + + + VkStructureType sType + void* pNext + VkSampleCountFlags sampleLocationSampleCounts + VkExtent2D maxSampleLocationGridSize + float sampleLocationCoordinateRange[2] + uint32_t sampleLocationSubPixelBits + VkBool32 variableSampleLocations + + + VkStructureType sType + void* pNext + VkExtent2D maxSampleLocationGridSize + + + VkStructureType sType + const void* pNext + VkSamplerReductionMode reductionMode + + + + VkStructureType sType + void* pNext + VkBool32 advancedBlendCoherentOperations + + + VkStructureType sType + void* pNext + VkBool32 multiDraw + + + VkStructureType sType + void* pNext + uint32_t advancedBlendMaxColorAttachments + VkBool32 advancedBlendIndependentBlend + VkBool32 advancedBlendNonPremultipliedSrcColor + VkBool32 advancedBlendNonPremultipliedDstColor + VkBool32 advancedBlendCorrelatedOverlap + VkBool32 advancedBlendAllOperations + + + VkStructureType sType + const void* pNext + VkBool32 srcPremultiplied + VkBool32 dstPremultiplied + VkBlendOverlapEXT blendOverlap + + + VkStructureType sType + void* pNext + VkBool32 inlineUniformBlock + VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind + + + VkStructureType sType + void* pNext + uint32_t maxInlineUniformBlockSize + uint32_t maxPerStageDescriptorInlineUniformBlocks + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks + uint32_t maxDescriptorSetInlineUniformBlocks + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks + + + VkStructureType sType + const void* pNext + uint32_t dataSize + const void* pData + + + VkStructureType sType + const void* pNext + uint32_t maxInlineUniformBlockBindings + + + VkStructureType sType + const void* pNext + VkPipelineCoverageModulationStateCreateFlagsNV flags + VkCoverageModulationModeNV coverageModulationMode + VkBool32 coverageModulationTableEnable + uint32_t coverageModulationTableCount + const float* pCoverageModulationTable + + + VkStructureType sType + const void* pNext + uint32_t viewFormatCount + const VkFormat* pViewFormats + + + + VkStructureType sType + const void* pNext + VkValidationCacheCreateFlagsEXT flags + size_t initialDataSize + const void* pInitialData + + + VkStructureType sType + const void* pNext + VkValidationCacheEXT validationCache + + + VkStructureType sType + void* pNext + uint32_t maxPerSetDescriptors + VkDeviceSize maxMemoryAllocationSize + + + + VkStructureType sType + void* pNext + VkBool32 maintenance4 + + + VkStructureType sType + void* pNext + VkDeviceSize maxBufferSize + + + VkStructureType sType + void* pNext + VkBool32 supported + + + + VkStructureType sType + void* pNext + VkBool32 shaderDrawParameters + + + + VkStructureType sType + void* pNext + VkBool32 shaderFloat1616-bit floats (halfs) in shaders + VkBool32 shaderInt88-bit integers in shaders + + + + + VkStructureType sType + void* pNext + VkShaderFloatControlsIndependence denormBehaviorIndependence + VkShaderFloatControlsIndependence roundingModeIndependence + VkBool32 shaderSignedZeroInfNanPreserveFloat16An implementation can preserve signed zero, nan, inf + VkBool32 shaderSignedZeroInfNanPreserveFloat32An implementation can preserve signed zero, nan, inf + VkBool32 shaderSignedZeroInfNanPreserveFloat64An implementation can preserve signed zero, nan, inf + VkBool32 shaderDenormPreserveFloat16An implementation can preserve denormals + VkBool32 shaderDenormPreserveFloat32An implementation can preserve denormals + VkBool32 shaderDenormPreserveFloat64An implementation can preserve denormals + VkBool32 shaderDenormFlushToZeroFloat16An implementation can flush to zero denormals + VkBool32 shaderDenormFlushToZeroFloat32An implementation can flush to zero denormals + VkBool32 shaderDenormFlushToZeroFloat64An implementation can flush to zero denormals + VkBool32 shaderRoundingModeRTEFloat16An implementation can support RTE + VkBool32 shaderRoundingModeRTEFloat32An implementation can support RTE + VkBool32 shaderRoundingModeRTEFloat64An implementation can support RTE + VkBool32 shaderRoundingModeRTZFloat16An implementation can support RTZ + VkBool32 shaderRoundingModeRTZFloat32An implementation can support RTZ + VkBool32 shaderRoundingModeRTZFloat64An implementation can support RTZ + + + + VkStructureType sType + void* pNext + VkBool32 hostQueryReset + + + + uint64_t consumer + uint64_t producer + + + VkStructureType sType + const void* pNext + const void* handle + int stride + int format + int usage + VkNativeBufferUsage2ANDROID usage2 + + + VkStructureType sType + const void* pNext + VkSwapchainImageUsageFlagsANDROID usage + + + VkStructureType sType + const void* pNext + VkBool32 sharedImage + + + uint32_t numUsedVgprs + uint32_t numUsedSgprs + uint32_t ldsSizePerLocalWorkGroup + size_t ldsUsageSizeInBytes + size_t scratchMemUsageInBytes + + + VkShaderStageFlags shaderStageMask + VkShaderResourceUsageAMD resourceUsage + uint32_t numPhysicalVgprs + uint32_t numPhysicalSgprs + uint32_t numAvailableVgprs + uint32_t numAvailableSgprs + uint32_t computeWorkGroupSize[3] + + + VkStructureType sType + const void* pNext + VkQueueGlobalPriorityEXT globalPriority + + + VkStructureType sType + void* pNext + VkBool32 globalPriorityQuery + + + VkStructureType sType + void* pNext + uint32_t priorityCount + VkQueueGlobalPriorityEXT priorities[VK_MAX_GLOBAL_PRIORITY_SIZE_EXT] + + + VkStructureType sType + const void* pNext + VkObjectType objectType + uint64_t objectHandle + const char* pObjectName + + + VkStructureType sType + const void* pNext + VkObjectType objectType + uint64_t objectHandle + uint64_t tagName + size_t tagSize + const void* pTag + + + VkStructureType sType + const void* pNext + const char* pLabelName + float color[4] + + + VkStructureType sType + const void* pNext + VkDebugUtilsMessengerCreateFlagsEXT flags + VkDebugUtilsMessageSeverityFlagsEXT messageSeverity + VkDebugUtilsMessageTypeFlagsEXT messageType + PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback + void* pUserData + + + VkStructureType sType + const void* pNext + VkDebugUtilsMessengerCallbackDataFlagsEXT flags + const char* pMessageIdName + int32_t messageIdNumber + const char* pMessage + uint32_t queueLabelCount + const VkDebugUtilsLabelEXT* pQueueLabels + uint32_t cmdBufLabelCount + const VkDebugUtilsLabelEXT* pCmdBufLabels + uint32_t objectCount + const VkDebugUtilsObjectNameInfoEXT* pObjects + + + VkStructureType sType + void* pNext + VkBool32 deviceMemoryReport + + + VkStructureType sType + const void* pNext + VkDeviceMemoryReportFlagsEXT flags + PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback + void* pUserData + + + VkStructureType sType + void* pNext + VkDeviceMemoryReportFlagsEXT flags + VkDeviceMemoryReportEventTypeEXT type + uint64_t memoryObjectId + VkDeviceSize size + VkObjectType objectType + uint64_t objectHandle + uint32_t heapIndex + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagBits handleType + void* pHostPointer + + + VkStructureType sType + void* pNext + uint32_t memoryTypeBits + + + VkStructureType sType + void* pNext + VkDeviceSize minImportedHostPointerAlignment + + + VkStructureType sType + void* pNext + float primitiveOverestimationSizeThe size in pixels the primitive is enlarged at each edge during conservative rasterization + float maxExtraPrimitiveOverestimationSizeThe maximum additional overestimation the client can specify in the pipeline state + float extraPrimitiveOverestimationSizeGranularityThe granularity of extra overestimation sizes the implementations supports between 0 and maxExtraOverestimationSize + VkBool32 primitiveUnderestimationtrue if the implementation supports conservative rasterization underestimation mode + VkBool32 conservativePointAndLineRasterizationtrue if conservative rasterization also applies to points and lines + VkBool32 degenerateTrianglesRasterizedtrue if degenerate triangles (those with zero area after snap) are rasterized + VkBool32 degenerateLinesRasterizedtrue if degenerate lines (those with zero length after snap) are rasterized + VkBool32 fullyCoveredFragmentShaderInputVariabletrue if the implementation supports the FullyCoveredEXT SPIR-V builtin fragment shader input variable + VkBool32 conservativeRasterizationPostDepthCoveragetrue if the implementation supports both conservative rasterization and post depth coverage sample coverage mask + + + VkStructureType sType + const void* pNext + VkTimeDomainEXT timeDomain + + + VkStructureType sType + void* pNext + uint32_t shaderEngineCountnumber of shader engines + uint32_t shaderArraysPerEngineCountnumber of shader arrays + uint32_t computeUnitsPerShaderArraynumber of physical CUs per shader array + uint32_t simdPerComputeUnitnumber of SIMDs per compute unit + uint32_t wavefrontsPerSimdnumber of wavefront slots in each SIMD + uint32_t wavefrontSizemaximum number of threads per wavefront + uint32_t sgprsPerSimdnumber of physical SGPRs per SIMD + uint32_t minSgprAllocationminimum number of SGPRs that can be allocated by a wave + uint32_t maxSgprAllocationnumber of available SGPRs + uint32_t sgprAllocationGranularitySGPRs are allocated in groups of this size + uint32_t vgprsPerSimdnumber of physical VGPRs per SIMD + uint32_t minVgprAllocationminimum number of VGPRs that can be allocated by a wave + uint32_t maxVgprAllocationnumber of available VGPRs + uint32_t vgprAllocationGranularityVGPRs are allocated in groups of this size + + + VkStructureType sType + void* pNextPointer to next structure + VkShaderCorePropertiesFlagsAMD shaderCoreFeaturesfeatures supported by the shader core + uint32_t activeComputeUnitCountnumber of active compute units across all shader engines/arrays + + + VkStructureType sType + const void* pNext + VkPipelineRasterizationConservativeStateCreateFlagsEXT flagsReserved + VkConservativeRasterizationModeEXT conservativeRasterizationModeConservative rasterization mode + float extraPrimitiveOverestimationSizeExtra overestimation to add to the primitive + + + VkStructureType sType + void* pNext + VkBool32 shaderInputAttachmentArrayDynamicIndexing + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing + VkBool32 shaderUniformBufferArrayNonUniformIndexing + VkBool32 shaderSampledImageArrayNonUniformIndexing + VkBool32 shaderStorageBufferArrayNonUniformIndexing + VkBool32 shaderStorageImageArrayNonUniformIndexing + VkBool32 shaderInputAttachmentArrayNonUniformIndexing + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing + VkBool32 descriptorBindingUniformBufferUpdateAfterBind + VkBool32 descriptorBindingSampledImageUpdateAfterBind + VkBool32 descriptorBindingStorageImageUpdateAfterBind + VkBool32 descriptorBindingStorageBufferUpdateAfterBind + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind + VkBool32 descriptorBindingUpdateUnusedWhilePending + VkBool32 descriptorBindingPartiallyBound + VkBool32 descriptorBindingVariableDescriptorCount + VkBool32 runtimeDescriptorArray + + + + VkStructureType sType + void* pNext + uint32_t maxUpdateAfterBindDescriptorsInAllPools + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative + VkBool32 shaderSampledImageArrayNonUniformIndexingNative + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative + VkBool32 shaderStorageImageArrayNonUniformIndexingNative + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative + VkBool32 robustBufferAccessUpdateAfterBind + VkBool32 quadDivergentImplicitLod + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments + uint32_t maxPerStageUpdateAfterBindResources + uint32_t maxDescriptorSetUpdateAfterBindSamplers + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic + uint32_t maxDescriptorSetUpdateAfterBindSampledImages + uint32_t maxDescriptorSetUpdateAfterBindStorageImages + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments + + + + VkStructureType sType + const void* pNext + uint32_t bindingCount + const VkDescriptorBindingFlags* pBindingFlags + + + + VkStructureType sType + const void* pNext + uint32_t descriptorSetCount + const uint32_t* pDescriptorCounts + + + + VkStructureType sType + void* pNext + uint32_t maxVariableDescriptorCount + + + + VkStructureType sType + const void* pNext + VkAttachmentDescriptionFlags flags + VkFormat format + VkSampleCountFlagBits samples + VkAttachmentLoadOp loadOpLoad operation for color or depth data + VkAttachmentStoreOp storeOpStore operation for color or depth data + VkAttachmentLoadOp stencilLoadOpLoad operation for stencil data + VkAttachmentStoreOp stencilStoreOpStore operation for stencil data + VkImageLayout initialLayout + VkImageLayout finalLayout + + + + VkStructureType sType + const void* pNext + uint32_t attachment + VkImageLayout layout + VkImageAspectFlags aspectMask + + + + VkStructureType sType + const void* pNext + VkSubpassDescriptionFlags flags + VkPipelineBindPoint pipelineBindPoint + uint32_t viewMask + uint32_t inputAttachmentCount + const VkAttachmentReference2* pInputAttachments + uint32_t colorAttachmentCount + const VkAttachmentReference2* pColorAttachments + const VkAttachmentReference2* pResolveAttachments + const VkAttachmentReference2* pDepthStencilAttachment + uint32_t preserveAttachmentCount + const uint32_t* pPreserveAttachments + + + + VkStructureType sType + const void* pNext + uint32_t srcSubpass + uint32_t dstSubpass + VkPipelineStageFlags srcStageMask + VkPipelineStageFlags dstStageMask + VkAccessFlags srcAccessMask + VkAccessFlags dstAccessMask + VkDependencyFlags dependencyFlags + int32_t viewOffset + + + + VkStructureType sType + const void* pNext + VkRenderPassCreateFlags flags + uint32_t attachmentCount + const VkAttachmentDescription2* pAttachments + uint32_t subpassCount + const VkSubpassDescription2* pSubpasses + uint32_t dependencyCount + const VkSubpassDependency2* pDependencies + uint32_t correlatedViewMaskCount + const uint32_t* pCorrelatedViewMasks + + + + VkStructureType sType + const void* pNext + VkSubpassContents contents + + + + VkStructureType sType + const void* pNext + + + + VkStructureType sType + void* pNext + VkBool32 timelineSemaphore + + + + VkStructureType sType + void* pNext + uint64_t maxTimelineSemaphoreValueDifference + + + + VkStructureType sType + const void* pNext + VkSemaphoreType semaphoreType + uint64_t initialValue + + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreValueCount + const uint64_t* pWaitSemaphoreValues + uint32_t signalSemaphoreValueCount + const uint64_t* pSignalSemaphoreValues + + + + VkStructureType sType + const void* pNext + VkSemaphoreWaitFlags flags + uint32_t semaphoreCount + const VkSemaphore* pSemaphores + const uint64_t* pValues + + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + uint64_t value + + + + uint32_t binding + uint32_t divisor + + + VkStructureType sType + const void* pNext + uint32_t vertexBindingDivisorCount + const VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors + + + VkStructureType sType + void* pNext + uint32_t maxVertexAttribDivisormax value of vertex attribute divisor + + + VkStructureType sType + void* pNext + uint32_t pciDomain + uint32_t pciBus + uint32_t pciDevice + uint32_t pciFunction + + + VkStructureType sType + const void* pNext + struct AHardwareBuffer* buffer + + + VkStructureType sType + void* pNext + uint64_t androidHardwareBufferUsage + + + VkStructureType sType + void* pNext + VkDeviceSize allocationSize + uint32_t memoryTypeBits + + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + + + VkStructureType sType + void* pNext + VkFormat format + uint64_t externalFormat + VkFormatFeatureFlags formatFeatures + VkComponentMapping samplerYcbcrConversionComponents + VkSamplerYcbcrModelConversion suggestedYcbcrModel + VkSamplerYcbcrRange suggestedYcbcrRange + VkChromaLocation suggestedXChromaOffset + VkChromaLocation suggestedYChromaOffset + + + VkStructureType sType + const void* pNext + VkBool32 conditionalRenderingEnableWhether this secondary command buffer may be executed during an active conditional rendering + + + VkStructureType sType + void* pNext + uint64_t externalFormat + + + VkStructureType sType + void* pNext + VkBool32 storageBuffer8BitAccess8-bit integer variables supported in StorageBuffer + VkBool32 uniformAndStorageBuffer8BitAccess8-bit integer variables supported in StorageBuffer and Uniform + VkBool32 storagePushConstant88-bit integer variables supported in PushConstant + + + + VkStructureType sType + void* pNext + VkBool32 conditionalRendering + VkBool32 inheritedConditionalRendering + + + VkStructureType sType + void* pNext + VkBool32 vulkanMemoryModel + VkBool32 vulkanMemoryModelDeviceScope + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains + + + + VkStructureType sType + void* pNext + VkBool32 shaderBufferInt64Atomics + VkBool32 shaderSharedInt64Atomics + + + + VkStructureType sType + void* pNext + VkBool32 shaderBufferFloat32Atomics + VkBool32 shaderBufferFloat32AtomicAdd + VkBool32 shaderBufferFloat64Atomics + VkBool32 shaderBufferFloat64AtomicAdd + VkBool32 shaderSharedFloat32Atomics + VkBool32 shaderSharedFloat32AtomicAdd + VkBool32 shaderSharedFloat64Atomics + VkBool32 shaderSharedFloat64AtomicAdd + VkBool32 shaderImageFloat32Atomics + VkBool32 shaderImageFloat32AtomicAdd + VkBool32 sparseImageFloat32Atomics + VkBool32 sparseImageFloat32AtomicAdd + + + VkStructureType sType + void* pNext + VkBool32 shaderBufferFloat16Atomics + VkBool32 shaderBufferFloat16AtomicAdd + VkBool32 shaderBufferFloat16AtomicMinMax + VkBool32 shaderBufferFloat32AtomicMinMax + VkBool32 shaderBufferFloat64AtomicMinMax + VkBool32 shaderSharedFloat16Atomics + VkBool32 shaderSharedFloat16AtomicAdd + VkBool32 shaderSharedFloat16AtomicMinMax + VkBool32 shaderSharedFloat32AtomicMinMax + VkBool32 shaderSharedFloat64AtomicMinMax + VkBool32 shaderImageFloat32AtomicMinMax + VkBool32 sparseImageFloat32AtomicMinMax + + + VkStructureType sType + void* pNext + VkBool32 vertexAttributeInstanceRateDivisor + VkBool32 vertexAttributeInstanceRateZeroDivisor + + + VkStructureType sType + void* pNext + VkPipelineStageFlags checkpointExecutionStageMask + + + VkStructureType sType + void* pNext + VkPipelineStageFlagBits stage + void* pCheckpointMarker + + + VkStructureType sType + void* pNext + VkResolveModeFlags supportedDepthResolveModessupported depth resolve modes + VkResolveModeFlags supportedStencilResolveModessupported stencil resolve modes + VkBool32 independentResolveNonedepth and stencil resolve modes can be set independently if one of them is none + VkBool32 independentResolvedepth and stencil resolve modes can be set independently + + + + VkStructureType sType + const void* pNext + VkResolveModeFlagBits depthResolveModedepth resolve mode + VkResolveModeFlagBits stencilResolveModestencil resolve mode + const VkAttachmentReference2* pDepthStencilResolveAttachmentdepth/stencil resolve attachment + + + + VkStructureType sType + const void* pNext + VkFormat decodeMode + + + VkStructureType sType + void* pNext + VkBool32 decodeModeSharedExponent + + + VkStructureType sType + void* pNext + VkBool32 transformFeedback + VkBool32 geometryStreams + + + VkStructureType sType + void* pNext + uint32_t maxTransformFeedbackStreams + uint32_t maxTransformFeedbackBuffers + VkDeviceSize maxTransformFeedbackBufferSize + uint32_t maxTransformFeedbackStreamDataSize + uint32_t maxTransformFeedbackBufferDataSize + uint32_t maxTransformFeedbackBufferDataStride + VkBool32 transformFeedbackQueries + VkBool32 transformFeedbackStreamsLinesTriangles + VkBool32 transformFeedbackRasterizationStreamSelect + VkBool32 transformFeedbackDraw + + + VkStructureType sType + const void* pNext + VkPipelineRasterizationStateStreamCreateFlagsEXT flags + uint32_t rasterizationStream + + + VkStructureTypesType + void* pNext + VkBool32 representativeFragmentTest + + + VkStructureType sType + const void* pNext + VkBool32 representativeFragmentTestEnable + + + VkStructureType sType + void* pNext + VkBool32 exclusiveScissor + + + VkStructureType sType + const void* pNext + uint32_t exclusiveScissorCount + const VkRect2D* pExclusiveScissors + + + VkStructureType sType + void* pNext + VkBool32 cornerSampledImage + + + VkStructureType sType + void* pNext + VkBool32 computeDerivativeGroupQuads + VkBool32 computeDerivativeGroupLinear + + + VkStructureType sType + void* pNext + VkBool32 fragmentShaderBarycentric + + + VkStructureType sType + void* pNext + VkBool32 imageFootprint + + + VkStructureType sType + void* pNext + VkBool32 dedicatedAllocationImageAliasing + + + uint32_t shadingRatePaletteEntryCount + const VkShadingRatePaletteEntryNV* pShadingRatePaletteEntries + + + VkStructureType sType + const void* pNext + VkBool32 shadingRateImageEnable + uint32_t viewportCount + const VkShadingRatePaletteNV* pShadingRatePalettes + + + VkStructureType sType + void* pNext + VkBool32 shadingRateImage + VkBool32 shadingRateCoarseSampleOrder + + + VkStructureType sType + void* pNext + VkExtent2D shadingRateTexelSize + uint32_t shadingRatePaletteSize + uint32_t shadingRateMaxCoarseSamples + + + VkStructureType sType + void* pNext + VkBool32 invocationMask + + + uint32_t pixelX + uint32_t pixelY + uint32_t sample + + + VkShadingRatePaletteEntryNV shadingRate + uint32_t sampleCount + uint32_t sampleLocationCount + const VkCoarseSampleLocationNV* pSampleLocations + + + VkStructureType sType + const void* pNext + VkCoarseSampleOrderTypeNV sampleOrderType + uint32_t customSampleOrderCount + const VkCoarseSampleOrderCustomNV* pCustomSampleOrders + + + VkStructureType sType + void* pNext + VkBool32 taskShader + VkBool32 meshShader + + + VkStructureType sType + void* pNext + uint32_t maxDrawMeshTasksCount + uint32_t maxTaskWorkGroupInvocations + uint32_t maxTaskWorkGroupSize[3] + uint32_t maxTaskTotalMemorySize + uint32_t maxTaskOutputCount + uint32_t maxMeshWorkGroupInvocations + uint32_t maxMeshWorkGroupSize[3] + uint32_t maxMeshTotalMemorySize + uint32_t maxMeshOutputVertices + uint32_t maxMeshOutputPrimitives + uint32_t maxMeshMultiviewViewCount + uint32_t meshOutputPerVertexGranularity + uint32_t meshOutputPerPrimitiveGranularity + + + uint32_t taskCount + uint32_t firstTask + + + VkStructureType sType + const void* pNext + VkRayTracingShaderGroupTypeKHR type + uint32_t generalShader + uint32_t closestHitShader + uint32_t anyHitShader + uint32_t intersectionShader + + + VkStructureType sType + const void* pNext + VkRayTracingShaderGroupTypeKHR type + uint32_t generalShader + uint32_t closestHitShader + uint32_t anyHitShader + uint32_t intersectionShader + const void* pShaderGroupCaptureReplayHandle + + + VkStructureType sType + const void* pNext + VkPipelineCreateFlags flagsPipeline creation flags + uint32_t stageCount + const VkPipelineShaderStageCreateInfo* pStagesOne entry for each active shader stage + uint32_t groupCount + const VkRayTracingShaderGroupCreateInfoNV* pGroups + uint32_t maxRecursionDepth + VkPipelineLayout layoutInterface layout of the pipeline + VkPipeline basePipelineHandleIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of + int32_t basePipelineIndexIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of + + + VkStructureType sType + const void* pNext + VkPipelineCreateFlags flagsPipeline creation flags + uint32_t stageCount + const VkPipelineShaderStageCreateInfo* pStagesOne entry for each active shader stage + uint32_t groupCount + const VkRayTracingShaderGroupCreateInfoKHR* pGroups + uint32_t maxPipelineRayRecursionDepth + const VkPipelineLibraryCreateInfoKHR* pLibraryInfo + const VkRayTracingPipelineInterfaceCreateInfoKHR* pLibraryInterface + const VkPipelineDynamicStateCreateInfo* pDynamicState + VkPipelineLayout layoutInterface layout of the pipeline + VkPipeline basePipelineHandleIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of + int32_t basePipelineIndexIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of + + + VkStructureType sType + const void* pNext + VkBuffer vertexData + VkDeviceSize vertexOffset + uint32_t vertexCount + VkDeviceSize vertexStride + VkFormat vertexFormat + VkBuffer indexData + VkDeviceSize indexOffset + uint32_t indexCount + VkIndexType indexType + VkBuffer transformDataOptional reference to array of floats representing a 3x4 row major affine transformation matrix. + VkDeviceSize transformOffset + + + VkStructureType sType + const void* pNext + VkBuffer aabbData + uint32_t numAABBs + uint32_t strideStride in bytes between AABBs + VkDeviceSize offsetOffset in bytes of the first AABB in aabbData + + + VkGeometryTrianglesNV triangles + VkGeometryAABBNV aabbs + + + VkStructureType sType + const void* pNext + VkGeometryTypeKHR geometryType + VkGeometryDataNV geometry + VkGeometryFlagsKHR flags + + + VkStructureType sType + const void* pNext + VkAccelerationStructureTypeNV type + VkBuildAccelerationStructureFlagsNVflags + uint32_t instanceCount + uint32_t geometryCount + const VkGeometryNV* pGeometries + + + VkStructureType sType + const void* pNext + VkDeviceSize compactedSize + VkAccelerationStructureInfoNV info + + + VkStructureType sType + const void* pNext + VkAccelerationStructureNV accelerationStructure + VkDeviceMemory memory + VkDeviceSize memoryOffset + uint32_t deviceIndexCount + const uint32_t* pDeviceIndices + + + VkStructureType sType + const void* pNext + uint32_t accelerationStructureCount + const VkAccelerationStructureKHR* pAccelerationStructures + + + VkStructureType sType + const void* pNext + uint32_t accelerationStructureCount + const VkAccelerationStructureNV* pAccelerationStructures + + + VkStructureType sType + const void* pNext + VkAccelerationStructureMemoryRequirementsTypeNV type + VkAccelerationStructureNV accelerationStructure + + + VkStructureType sType + void* pNext + VkBool32 accelerationStructure + VkBool32 accelerationStructureCaptureReplay + VkBool32 accelerationStructureIndirectBuild + VkBool32 accelerationStructureHostCommands + VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind + + + VkStructureType sType + void* pNext + VkBool32 rayTracingPipeline + VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay + VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed + VkBool32 rayTracingPipelineTraceRaysIndirect + VkBool32 rayTraversalPrimitiveCulling + + + VkStructureType sType + void* pNext + VkBool32 rayQuery + + + VkStructureType sType + void* pNext + uint64_t maxGeometryCount + uint64_t maxInstanceCount + uint64_t maxPrimitiveCount + uint32_t maxPerStageDescriptorAccelerationStructures + uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures + uint32_t maxDescriptorSetAccelerationStructures + uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures + uint32_t minAccelerationStructureScratchOffsetAlignment + + + VkStructureType sType + void* pNext + uint32_t shaderGroupHandleSize + uint32_t maxRayRecursionDepth + uint32_t maxShaderGroupStride + uint32_t shaderGroupBaseAlignment + uint32_t shaderGroupHandleCaptureReplaySize + uint32_t maxRayDispatchInvocationCount + uint32_t shaderGroupHandleAlignment + uint32_t maxRayHitAttributeSize + + + VkStructureType sType + void* pNext + uint32_t shaderGroupHandleSize + uint32_t maxRecursionDepth + uint32_t maxShaderGroupStride + uint32_t shaderGroupBaseAlignment + uint64_t maxGeometryCount + uint64_t maxInstanceCount + uint64_t maxTriangleCount + uint32_t maxDescriptorSetAccelerationStructures + + + VkDeviceAddress deviceAddress + VkDeviceSize stride + VkDeviceSize size + + + uint32_t width + uint32_t height + uint32_t depth + + + VkStructureType sType + void* pNext + uint32_t drmFormatModifierCount + VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties + + + uint64_t drmFormatModifier + uint32_t drmFormatModifierPlaneCount + VkFormatFeatureFlags drmFormatModifierTilingFeatures + + + VkStructureType sType + const void* pNext + uint64_t drmFormatModifier + VkSharingMode sharingMode + uint32_t queueFamilyIndexCount + const uint32_t* pQueueFamilyIndices + + + VkStructureType sType + const void* pNext + uint32_t drmFormatModifierCount + const uint64_t* pDrmFormatModifiers + + + VkStructureType sType + const void* pNext + uint64_t drmFormatModifier + uint32_t drmFormatModifierPlaneCount + const VkSubresourceLayout* pPlaneLayouts + + + VkStructureType sType + void* pNext + uint64_t drmFormatModifier + + + VkStructureType sType + const void* pNext + VkImageUsageFlags stencilUsage + + + + VkStructureType sType + const void* pNext + VkMemoryOverallocationBehaviorAMD overallocationBehavior + + + VkStructureType sType + void* pNext + VkBool32 fragmentDensityMap + VkBool32 fragmentDensityMapDynamic + VkBool32 fragmentDensityMapNonSubsampledImages + + + VkStructureType sType + void* pNext + VkBool32 fragmentDensityMapDeferred + + + VkStructureType sType + void* pNext + VkExtent2D minFragmentDensityTexelSize + VkExtent2D maxFragmentDensityTexelSize + VkBool32 fragmentDensityInvocations + + + VkStructureType sType + void* pNext + VkBool32 subsampledLoads + VkBool32 subsampledCoarseReconstructionEarlyAccess + uint32_t maxSubsampledArrayLayers + uint32_t maxDescriptorSetSubsampledSamplers + + + VkStructureType sType + const void* pNext + VkAttachmentReference fragmentDensityMapAttachment + + + VkStructureType sType + void* pNext + VkBool32 scalarBlockLayout + + + + VkStructureType sType + const void* pNext + VkBool32 supportsProtectedRepresents if surface can be protected + + + VkStructureType sType + void* pNext + VkBool32 uniformBufferStandardLayout + + + + VkStructureType sType + void* pNext + VkBool32 depthClipEnable + + + VkStructureType sType + const void* pNext + VkPipelineRasterizationDepthClipStateCreateFlagsEXT flagsReserved + VkBool32 depthClipEnable + + + VkStructureType sType + void* pNext + VkDeviceSize heapBudget[VK_MAX_MEMORY_HEAPS] + VkDeviceSize heapUsage[VK_MAX_MEMORY_HEAPS] + + + VkStructureType sType + void* pNext + VkBool32 memoryPriority + + + VkStructureType sType + const void* pNext + float priority + + + VkStructureType sType + void* pNext + VkBool32 pageableDeviceLocalMemory + + + VkStructureType sType + void* pNext + VkBool32 bufferDeviceAddress + VkBool32 bufferDeviceAddressCaptureReplay + VkBool32 bufferDeviceAddressMultiDevice + + + + VkStructureType sType + void* pNext + VkBool32 bufferDeviceAddress + VkBool32 bufferDeviceAddressCaptureReplay + VkBool32 bufferDeviceAddressMultiDevice + + + + VkStructureType sType + const void* pNext + VkBuffer buffer + + + + + VkStructureType sType + const void* pNext + uint64_t opaqueCaptureAddress + + + + VkStructureType sType + const void* pNext + VkDeviceAddress deviceAddress + + + VkStructureType sType + void* pNext + VkImageViewType imageViewType + + + VkStructureType sType + void* pNext + VkBool32 filterCubicThe combinations of format, image type (and image view type if provided) can be filtered with VK_FILTER_CUBIC_EXT + VkBool32 filterCubicMinmaxThe combination of format, image type (and image view type if provided) can be filtered with VK_FILTER_CUBIC_EXT and ReductionMode of Min or Max + + + VkStructureType sType + void* pNext + VkBool32 imagelessFramebuffer + + + + VkStructureType sType + const void* pNext + uint32_t attachmentImageInfoCount + const VkFramebufferAttachmentImageInfo* pAttachmentImageInfos + + + + VkStructureType sType + const void* pNext + VkImageCreateFlags flagsImage creation flags + VkImageUsageFlags usageImage usage flags + uint32_t width + uint32_t height + uint32_t layerCount + uint32_t viewFormatCount + const VkFormat* pViewFormats + + + + VkStructureType sType + const void* pNext + uint32_t attachmentCount + const VkImageView* pAttachments + + + + VkStructureType sType + void* pNext + VkBool32 textureCompressionASTC_HDR + + + VkStructureType sType + void* pNext + VkBool32 cooperativeMatrix + VkBool32 cooperativeMatrixRobustBufferAccess + + + VkStructureType sType + void* pNext + VkShaderStageFlags cooperativeMatrixSupportedStages + + + VkStructureType sType + void* pNext + uint32_t MSize + uint32_t NSize + uint32_t KSize + VkComponentTypeNV AType + VkComponentTypeNV BType + VkComponentTypeNV CType + VkComponentTypeNV DType + VkScopeNV scope + + + VkStructureType sType + void* pNext + VkBool32 ycbcrImageArrays + + + VkStructureType sType + const void* pNext + VkImageView imageView + VkDescriptorType descriptorType + VkSampler sampler + + + VkStructureType sType + void* pNext + VkDeviceAddress deviceAddress + VkDeviceSize size + + + VkStructureType sType + const void* pNext + GgpFrameToken frameToken + + + VkPipelineCreationFeedbackFlagsEXT flags + uint64_t duration + + + VkStructureType sType + const void* pNext + VkPipelineCreationFeedbackEXT* pPipelineCreationFeedbackOutput pipeline creation feedback. + uint32_t pipelineStageCreationFeedbackCount + VkPipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacksOne entry for each shader stage specified in the parent Vk*PipelineCreateInfo struct + + + VkStructureType sType + void* pNext + VkFullScreenExclusiveEXT fullScreenExclusive + + + VkStructureType sType + const void* pNext + HMONITOR hmonitor + + + VkStructureType sType + void* pNext + VkBool32 fullScreenExclusiveSupported + + + VkStructureType sType + void* pNext + VkBool32 performanceCounterQueryPoolsperformance counters supported in query pools + VkBool32 performanceCounterMultipleQueryPoolsperformance counters from multiple query pools can be accessed in the same primary command buffer + + + VkStructureType sType + void* pNext + VkBool32 allowCommandBufferQueryCopiesFlag to specify whether performance queries are allowed to be used in vkCmdCopyQueryPoolResults + + + VkStructureType sType + void* pNext + VkPerformanceCounterUnitKHR unit + VkPerformanceCounterScopeKHR scope + VkPerformanceCounterStorageKHR storage + uint8_t uuid[VK_UUID_SIZE] + + + VkStructureType sType + void* pNext + VkPerformanceCounterDescriptionFlagsKHR flags + char name[VK_MAX_DESCRIPTION_SIZE] + char category[VK_MAX_DESCRIPTION_SIZE] + char description[VK_MAX_DESCRIPTION_SIZE] + + + VkStructureType sType + const void* pNext + uint32_t queueFamilyIndex + uint32_t counterIndexCount + const uint32_t* pCounterIndices + + + int32_t int32 + int64_t int64 + uint32_t uint32 + uint64_t uint64 + float float32 + double float64 + + + VkStructureType sType + const void* pNext + VkAcquireProfilingLockFlagsKHR flagsAcquire profiling lock flags + uint64_t timeout + + + VkStructureType sType + const void* pNext + uint32_t counterPassIndexIndex for which counter pass to submit + + + VkStructureType sType + const void* pNext + uint32_t maxPerformanceQueriesPerPoolMaximum number of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR queries in a query pool + + + VkStructureType sType + const void* pNext + VkHeadlessSurfaceCreateFlagsEXT flags + + + VkStructureTypesType + void* pNext + VkBool32 coverageReductionMode + + + VkStructureType sType + const void* pNext + VkPipelineCoverageReductionStateCreateFlagsNV flags + VkCoverageReductionModeNV coverageReductionMode + + + VkStructureType sType + void* pNext + VkCoverageReductionModeNV coverageReductionMode + VkSampleCountFlagBits rasterizationSamples + VkSampleCountFlags depthStencilSamples + VkSampleCountFlags colorSamples + + + VkStructureType sType + void* pNext + VkBool32 shaderIntegerFunctions2 + + + uint32_t value32 + uint64_t value64 + float valueFloat + VkBool32 valueBool + const char* valueString + + + VkPerformanceValueTypeINTEL type + VkPerformanceValueDataINTEL data + + + VkStructureType sType + const void* pNext + void* pUserData + + + VkStructureType sType + const void* pNext + VkQueryPoolSamplingModeINTEL performanceCountersSampling + + + + VkStructureType sType + const void* pNext + uint64_t marker + + + VkStructureType sType + const void* pNext + uint32_t marker + + + VkStructureType sType + const void* pNext + VkPerformanceOverrideTypeINTEL type + VkBool32 enable + uint64_t parameter + + + VkStructureType sType + const void* pNext + VkPerformanceConfigurationTypeINTEL type + + + VkStructureType sType + void* pNext + VkBool32 shaderSubgroupClock + VkBool32 shaderDeviceClock + + + VkStructureType sType + void* pNext + VkBool32 indexTypeUint8 + + + VkStructureType sType + void* pNext + uint32_t shaderSMCount + uint32_t shaderWarpsPerSM + + + VkStructureTypesType + void* pNext + VkBool32 shaderSMBuiltins + + + VkStructureType sType + void* pNextPointer to next structure + VkBool32 fragmentShaderSampleInterlock + VkBool32 fragmentShaderPixelInterlock + VkBool32 fragmentShaderShadingRateInterlock + + + VkStructureTypesType + void* pNext + VkBool32 separateDepthStencilLayouts + + + + VkStructureTypesType + void* pNext + VkImageLayout stencilLayout + + + VkStructureType sType + void* pNext + VkBool32 primitiveTopologyListRestart + VkBool32 primitiveTopologyPatchListRestart + + + + VkStructureTypesType + void* pNext + VkImageLayout stencilInitialLayout + VkImageLayout stencilFinalLayout + + + + VkStructureType sType + void* pNext + VkBool32 pipelineExecutableInfo + + + VkStructureType sType + const void* pNext + VkPipeline pipeline + + + VkStructureType sType + void* pNext + VkShaderStageFlags stages + char name[VK_MAX_DESCRIPTION_SIZE] + char description[VK_MAX_DESCRIPTION_SIZE] + uint32_t subgroupSize + + + VkStructureType sType + const void* pNext + VkPipeline pipeline + uint32_t executableIndex + + + VkBool32 b32 + int64_t i64 + uint64_t u64 + double f64 + + + VkStructureType sType + void* pNext + char name[VK_MAX_DESCRIPTION_SIZE] + char description[VK_MAX_DESCRIPTION_SIZE] + VkPipelineExecutableStatisticFormatKHR format + VkPipelineExecutableStatisticValueKHR value + + + VkStructureType sType + void* pNext + char name[VK_MAX_DESCRIPTION_SIZE] + char description[VK_MAX_DESCRIPTION_SIZE] + VkBool32 isText + size_t dataSize + void* pData + + + VkStructureType sType + void* pNext + VkBool32 shaderDemoteToHelperInvocation + + + VkStructureType sType + void* pNext + VkBool32 texelBufferAlignment + + + VkStructureType sType + void* pNext + VkDeviceSize storageTexelBufferOffsetAlignmentBytes + VkBool32 storageTexelBufferOffsetSingleTexelAlignment + VkDeviceSize uniformTexelBufferOffsetAlignmentBytes + VkBool32 uniformTexelBufferOffsetSingleTexelAlignment + + + VkStructureType sType + void* pNext + VkBool32 subgroupSizeControl + VkBool32 computeFullSubgroups + + + VkStructureType sType + void* pNext + uint32_t minSubgroupSizeThe minimum subgroup size supported by this device + uint32_t maxSubgroupSizeThe maximum subgroup size supported by this device + uint32_t maxComputeWorkgroupSubgroupsThe maximum number of subgroups supported in a workgroup + VkShaderStageFlags requiredSubgroupSizeStagesThe shader stages that support specifying a subgroup size + + + VkStructureType sType + void* pNext + uint32_t requiredSubgroupSize + + + VkStructureType sType + void* pNext + VkRenderPass renderPass + uint32_t subpass + + + VkStructureType sType + void* pNext + uint32_t maxSubpassShadingWorkgroupSizeAspectRatio + + + VkStructureType sType + const void* pNext + uint64_t opaqueCaptureAddress + + + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + + + + VkStructureType sType + void* pNext + VkBool32 rectangularLines + VkBool32 bresenhamLines + VkBool32 smoothLines + VkBool32 stippledRectangularLines + VkBool32 stippledBresenhamLines + VkBool32 stippledSmoothLines + + + VkStructureType sType + void* pNext + uint32_t lineSubPixelPrecisionBits + + + VkStructureType sType + const void* pNext + VkLineRasterizationModeEXT lineRasterizationMode + VkBool32 stippledLineEnable + uint32_t lineStippleFactor + uint16_t lineStipplePattern + + + VkStructureType sType + void* pNext + VkBool32 pipelineCreationCacheControl + + + VkStructureTypesType + void* pNext + VkBool32 storageBuffer16BitAccess16-bit integer/floating-point variables supported in BufferBlock + VkBool32 uniformAndStorageBuffer16BitAccess16-bit integer/floating-point variables supported in BufferBlock and Block + VkBool32 storagePushConstant1616-bit integer/floating-point variables supported in PushConstant + VkBool32 storageInputOutput1616-bit integer/floating-point variables supported in shader inputs and outputs + VkBool32 multiviewMultiple views in a renderpass + VkBool32 multiviewGeometryShaderMultiple views in a renderpass w/ geometry shader + VkBool32 multiviewTessellationShaderMultiple views in a renderpass w/ tessellation shader + VkBool32 variablePointersStorageBuffer + VkBool32 variablePointers + VkBool32 protectedMemory + VkBool32 samplerYcbcrConversionSampler color conversion supported + VkBool32 shaderDrawParameters + + + VkStructureTypesType + void* pNext + uint8_t deviceUUID[VK_UUID_SIZE] + uint8_t driverUUID[VK_UUID_SIZE] + uint8_t deviceLUID[VK_LUID_SIZE] + uint32_t deviceNodeMask + VkBool32 deviceLUIDValid + uint32_t subgroupSizeThe size of a subgroup for this queue. + VkShaderStageFlags subgroupSupportedStagesBitfield of what shader stages support subgroup operations + VkSubgroupFeatureFlags subgroupSupportedOperationsBitfield of what subgroup operations are supported. + VkBool32 subgroupQuadOperationsInAllStagesFlag to specify whether quad operations are available in all stages. + VkPointClippingBehavior pointClippingBehavior + uint32_t maxMultiviewViewCountmax number of views in a subpass + uint32_t maxMultiviewInstanceIndexmax instance index for a draw in a multiview subpass + VkBool32 protectedNoFault + uint32_t maxPerSetDescriptors + VkDeviceSize maxMemoryAllocationSize + + + VkStructureTypesType + void* pNext + VkBool32 samplerMirrorClampToEdge + VkBool32 drawIndirectCount + VkBool32 storageBuffer8BitAccess8-bit integer variables supported in StorageBuffer + VkBool32 uniformAndStorageBuffer8BitAccess8-bit integer variables supported in StorageBuffer and Uniform + VkBool32 storagePushConstant88-bit integer variables supported in PushConstant + VkBool32 shaderBufferInt64Atomics + VkBool32 shaderSharedInt64Atomics + VkBool32 shaderFloat1616-bit floats (halfs) in shaders + VkBool32 shaderInt88-bit integers in shaders + VkBool32 descriptorIndexing + VkBool32 shaderInputAttachmentArrayDynamicIndexing + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing + VkBool32 shaderUniformBufferArrayNonUniformIndexing + VkBool32 shaderSampledImageArrayNonUniformIndexing + VkBool32 shaderStorageBufferArrayNonUniformIndexing + VkBool32 shaderStorageImageArrayNonUniformIndexing + VkBool32 shaderInputAttachmentArrayNonUniformIndexing + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing + VkBool32 descriptorBindingUniformBufferUpdateAfterBind + VkBool32 descriptorBindingSampledImageUpdateAfterBind + VkBool32 descriptorBindingStorageImageUpdateAfterBind + VkBool32 descriptorBindingStorageBufferUpdateAfterBind + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind + VkBool32 descriptorBindingUpdateUnusedWhilePending + VkBool32 descriptorBindingPartiallyBound + VkBool32 descriptorBindingVariableDescriptorCount + VkBool32 runtimeDescriptorArray + VkBool32 samplerFilterMinmax + VkBool32 scalarBlockLayout + VkBool32 imagelessFramebuffer + VkBool32 uniformBufferStandardLayout + VkBool32 shaderSubgroupExtendedTypes + VkBool32 separateDepthStencilLayouts + VkBool32 hostQueryReset + VkBool32 timelineSemaphore + VkBool32 bufferDeviceAddress + VkBool32 bufferDeviceAddressCaptureReplay + VkBool32 bufferDeviceAddressMultiDevice + VkBool32 vulkanMemoryModel + VkBool32 vulkanMemoryModelDeviceScope + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains + VkBool32 shaderOutputViewportIndex + VkBool32 shaderOutputLayer + VkBool32 subgroupBroadcastDynamicId + + + VkStructureTypesType + void* pNext + VkDriverId driverID + char driverName[VK_MAX_DRIVER_NAME_SIZE] + char driverInfo[VK_MAX_DRIVER_INFO_SIZE] + VkConformanceVersion conformanceVersion + VkShaderFloatControlsIndependencedenormBehaviorIndependence + VkShaderFloatControlsIndependenceroundingModeIndependence + VkBool32 shaderSignedZeroInfNanPreserveFloat16An implementation can preserve signed zero, nan, inf + VkBool32 shaderSignedZeroInfNanPreserveFloat32An implementation can preserve signed zero, nan, inf + VkBool32 shaderSignedZeroInfNanPreserveFloat64An implementation can preserve signed zero, nan, inf + VkBool32 shaderDenormPreserveFloat16An implementation can preserve denormals + VkBool32 shaderDenormPreserveFloat32An implementation can preserve denormals + VkBool32 shaderDenormPreserveFloat64An implementation can preserve denormals + VkBool32 shaderDenormFlushToZeroFloat16An implementation can flush to zero denormals + VkBool32 shaderDenormFlushToZeroFloat32An implementation can flush to zero denormals + VkBool32 shaderDenormFlushToZeroFloat64An implementation can flush to zero denormals + VkBool32 shaderRoundingModeRTEFloat16An implementation can support RTE + VkBool32 shaderRoundingModeRTEFloat32An implementation can support RTE + VkBool32 shaderRoundingModeRTEFloat64An implementation can support RTE + VkBool32 shaderRoundingModeRTZFloat16An implementation can support RTZ + VkBool32 shaderRoundingModeRTZFloat32An implementation can support RTZ + VkBool32 shaderRoundingModeRTZFloat64An implementation can support RTZ + uint32_t maxUpdateAfterBindDescriptorsInAllPools + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative + VkBool32 shaderSampledImageArrayNonUniformIndexingNative + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative + VkBool32 shaderStorageImageArrayNonUniformIndexingNative + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative + VkBool32 robustBufferAccessUpdateAfterBind + VkBool32 quadDivergentImplicitLod + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments + uint32_t maxPerStageUpdateAfterBindResources + uint32_t maxDescriptorSetUpdateAfterBindSamplers + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic + uint32_t maxDescriptorSetUpdateAfterBindSampledImages + uint32_t maxDescriptorSetUpdateAfterBindStorageImages + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments + VkResolveModeFlags supportedDepthResolveModessupported depth resolve modes + VkResolveModeFlags supportedStencilResolveModessupported stencil resolve modes + VkBool32 independentResolveNonedepth and stencil resolve modes can be set independently if one of them is none + VkBool32 independentResolvedepth and stencil resolve modes can be set independently + VkBool32 filterMinmaxSingleComponentFormats + VkBool32 filterMinmaxImageComponentMapping + uint64_t maxTimelineSemaphoreValueDifference + VkSampleCountFlags framebufferIntegerColorSampleCounts + + + VkStructureType sType + const void* pNext + VkPipelineCompilerControlFlagsAMD compilerControlFlags + + + VkStructureType sType + void* pNext + VkBool32 deviceCoherentMemory + + + VkStructureType sType + void* pNext + VkFaultLevel faultLevel + VkFaultType faultType + + + VkStructureType sType + void* pNext + uint32_t faultCount + VkFaultData*pFaults + PFN_vkFaultCallbackFunction pfnFaultCallback + + + VkStructureType sType + void* pNext + char name[VK_MAX_EXTENSION_NAME_SIZE] + char version[VK_MAX_EXTENSION_NAME_SIZE] + VkToolPurposeFlagsEXT purposes + char description[VK_MAX_DESCRIPTION_SIZE] + char layer[VK_MAX_EXTENSION_NAME_SIZE] + + + VkStructureType sType + const void* pNext + VkClearColorValue customBorderColor + VkFormat format + + + VkStructureType sType + void* pNext + uint32_t maxCustomBorderColorSamplers + + + VkStructureType sType + void* pNext + VkBool32 customBorderColors + VkBool32 customBorderColorWithoutFormat + + + VkStructureType sType + const void* pNext + VkComponentMapping components + VkBool32 srgb + + + VkStructureType sType + void* pNext + VkBool32 borderColorSwizzle + VkBool32 borderColorSwizzleFromImage + + + VkDeviceAddress deviceAddress + void* hostAddress + + + VkDeviceAddress deviceAddress + const void* hostAddress + + + VkStructureType sType + const void* pNext + VkFormat vertexFormat + VkDeviceOrHostAddressConstKHR vertexData + VkDeviceSize vertexStride + uint32_t maxVertex + VkIndexType indexType + VkDeviceOrHostAddressConstKHR indexData + VkDeviceOrHostAddressConstKHR transformData + + + VkStructureType sType + const void* pNext + VkDeviceOrHostAddressConstKHR data + VkDeviceSize stride + + + VkStructureType sType + const void* pNext + VkBool32 arrayOfPointers + VkDeviceOrHostAddressConstKHR data + + + VkAccelerationStructureGeometryTrianglesDataKHR triangles + VkAccelerationStructureGeometryAabbsDataKHR aabbs + VkAccelerationStructureGeometryInstancesDataKHR instances + + + VkStructureType sType + const void* pNext + VkGeometryTypeKHR geometryType + VkAccelerationStructureGeometryDataKHR geometry + VkGeometryFlagsKHR flags + + + VkStructureType sType + const void* pNext + VkAccelerationStructureTypeKHR type + VkBuildAccelerationStructureFlagsKHR flags + VkBuildAccelerationStructureModeKHR mode + VkAccelerationStructureKHR srcAccelerationStructure + VkAccelerationStructureKHR dstAccelerationStructure + uint32_t geometryCount + const VkAccelerationStructureGeometryKHR* pGeometries + const VkAccelerationStructureGeometryKHR* const* ppGeometries + VkDeviceOrHostAddressKHR scratchData + + + uint32_t primitiveCount + uint32_t primitiveOffset + uint32_t firstVertex + uint32_t transformOffset + + + VkStructureType sType + const void* pNext + VkAccelerationStructureCreateFlagsKHR createFlags + VkBuffer buffer + VkDeviceSize offsetSpecified in bytes + VkDeviceSize size + VkAccelerationStructureTypeKHR type + VkDeviceAddress deviceAddress + + + float minX + float minY + float minZ + float maxX + float maxY + float maxZ + + + + float matrix[3][4] + + + + The bitfields in this structure are non-normative since bitfield ordering is implementation-defined in C. The specification defines the normative layout. + VkTransformMatrixKHR transform + uint32_t instanceCustomIndex:24 + uint32_t mask:8 + uint32_t instanceShaderBindingTableRecordOffset:24 + VkGeometryInstanceFlagsKHR flags:8 + uint64_t accelerationStructureReference + + + + VkStructureType sType + const void* pNext + VkAccelerationStructureKHR accelerationStructure + + + VkStructureType sType + const void* pNext + const uint8_t* pVersionData + + + VkStructureType sType + const void* pNext + VkAccelerationStructureKHR src + VkAccelerationStructureKHR dst + VkCopyAccelerationStructureModeKHR mode + + + VkStructureType sType + const void* pNext + VkAccelerationStructureKHR src + VkDeviceOrHostAddressKHR dst + VkCopyAccelerationStructureModeKHR mode + + + VkStructureType sType + const void* pNext + VkDeviceOrHostAddressConstKHR src + VkAccelerationStructureKHR dst + VkCopyAccelerationStructureModeKHR mode + + + VkStructureType sType + const void* pNext + uint32_t maxPipelineRayPayloadSize + uint32_t maxPipelineRayHitAttributeSize + + + VkStructureType sType + const void* pNext + uint32_t libraryCount + const VkPipeline* pLibraries + + + VkObjectType objectType + uint64_t objectHandle + VkRefreshObjectFlagsKHRflags + + + VkStructureType sType + const void* pNext + uint32_t objectCount + const VkRefreshObjectKHR* pObjects + + + VkStructureType sType + void* pNext + VkBool32 extendedDynamicState + + + VkStructureType sType + void* pNext + VkBool32 extendedDynamicState2 + VkBool32 extendedDynamicState2LogicOp + VkBool32 extendedDynamicState2PatchControlPoints + + + VkStructureType sType + void* pNextPointer to next structure + VkSurfaceTransformFlagBitsKHR transform + + + VkStructureType sType + const void* pNext + VkSurfaceTransformFlagBitsKHR transform + + + VkStructureType sType + void* pNextPointer to next structure + VkSurfaceTransformFlagBitsKHR transform + VkRect2D renderArea + + + VkStructureTypesType + void* pNext + VkBool32 diagnosticsConfig + + + VkStructureType sType + const void* pNext + VkDeviceDiagnosticsConfigFlagsNV flags + + + VkStructureType sType + const void* pNext + uint8_t pipelineIdentifier[VK_UUID_SIZE] + VkPipelineMatchControl matchControl + VkDeviceSize poolEntrySize + + + VkStructureType sType + void* pNext + VkBool32 shaderZeroInitializeWorkgroupMemory + + + VkStructureType sType + void* pNext + VkBool32 shaderSubgroupUniformControlFlow + + + VkStructureType sType + void* pNext + VkBool32 robustBufferAccess2 + VkBool32 robustImageAccess2 + VkBool32 nullDescriptor + + + VkStructureType sType + void* pNext + VkDeviceSize robustStorageBufferAccessSizeAlignment + VkDeviceSize robustUniformBufferAccessSizeAlignment + + + VkStructureType sType + void* pNext + VkBool32 robustImageAccess + + + VkStructureType sType + void* pNext + VkBool32 workgroupMemoryExplicitLayout + VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout + VkBool32 workgroupMemoryExplicitLayout8BitAccess + VkBool32 workgroupMemoryExplicitLayout16BitAccess + + + VkStructureType sType + void* pNext + VkBool32 constantAlphaColorBlendFactors + VkBool32 events + VkBool32 imageViewFormatReinterpretation + VkBool32 imageViewFormatSwizzle + VkBool32 imageView2DOn3DImage + VkBool32 multisampleArrayImage + VkBool32 mutableComparisonSamplers + VkBool32 pointPolygons + VkBool32 samplerMipLodBias + VkBool32 separateStencilMaskRef + VkBool32 shaderSampleRateInterpolationFunctions + VkBool32 tessellationIsolines + VkBool32 tessellationPointMode + VkBool32 triangleFans + VkBool32 vertexAttributeAccessBeyondStride + + + VkStructureType sType + void* pNext + uint32_t minVertexInputBindingStrideAlignment + + + VkStructureType sType + void* pNext + VkBool32 formatA4R4G4B4 + VkBool32 formatA4B4G4R4 + + + VkStructureType sType + void* pNext + VkBool32 subpassShading + + + VkStructureType sType + const void* pNext + VkDeviceSize srcOffsetSpecified in bytes + VkDeviceSize dstOffsetSpecified in bytes + VkDeviceSize sizeSpecified in bytes + + + VkStructureType sType + const void* pNext + VkImageSubresourceLayers srcSubresource + VkOffset3D srcOffsetSpecified in pixels for both compressed and uncompressed images + VkImageSubresourceLayers dstSubresource + VkOffset3D dstOffsetSpecified in pixels for both compressed and uncompressed images + VkExtent3D extentSpecified in pixels for both compressed and uncompressed images + + + VkStructureType sType + const void* pNext + VkImageSubresourceLayers srcSubresource + VkOffset3D srcOffsets[2]Specified in pixels for both compressed and uncompressed images + VkImageSubresourceLayers dstSubresource + VkOffset3D dstOffsets[2]Specified in pixels for both compressed and uncompressed images + + + VkStructureType sType + const void* pNext + VkDeviceSize bufferOffsetSpecified in bytes + uint32_t bufferRowLengthSpecified in texels + uint32_t bufferImageHeight + VkImageSubresourceLayers imageSubresource + VkOffset3D imageOffsetSpecified in pixels for both compressed and uncompressed images + VkExtent3D imageExtentSpecified in pixels for both compressed and uncompressed images + + + VkStructureType sType + const void* pNext + VkImageSubresourceLayers srcSubresource + VkOffset3D srcOffset + VkImageSubresourceLayers dstSubresource + VkOffset3D dstOffset + VkExtent3D extent + + + VkStructureType sType + const void* pNext + VkBuffer srcBuffer + VkBuffer dstBuffer + uint32_t regionCount + const VkBufferCopy2KHR* pRegions + + + VkStructureType sType + const void* pNext + VkImage srcImage + VkImageLayout srcImageLayout + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkImageCopy2KHR* pRegions + + + VkStructureType sType + const void* pNext + VkImage srcImage + VkImageLayout srcImageLayout + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkImageBlit2KHR* pRegions + VkFilter filter + + + VkStructureType sType + const void* pNext + VkBuffer srcBuffer + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkBufferImageCopy2KHR* pRegions + + + VkStructureType sType + const void* pNext + VkImage srcImage + VkImageLayout srcImageLayout + VkBuffer dstBuffer + uint32_t regionCount + const VkBufferImageCopy2KHR* pRegions + + + VkStructureType sType + const void* pNext + VkImage srcImage + VkImageLayout srcImageLayout + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkImageResolve2KHR* pRegions + + + VkStructureType sType + void* pNext + VkBool32 shaderImageInt64Atomics + VkBool32 sparseImageInt64Atomics + + + VkStructureType sType + const void* pNext + const VkAttachmentReference2* pFragmentShadingRateAttachment + VkExtent2D shadingRateAttachmentTexelSize + + + VkStructureType sType + const void* pNext + VkExtent2D fragmentSize + VkFragmentShadingRateCombinerOpKHR combinerOps[2] + + + VkStructureType sType + void* pNext + VkBool32 pipelineFragmentShadingRate + VkBool32 primitiveFragmentShadingRate + VkBool32 attachmentFragmentShadingRate + + + VkStructureType sType + void* pNext + VkExtent2D minFragmentShadingRateAttachmentTexelSize + VkExtent2D maxFragmentShadingRateAttachmentTexelSize + uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio + VkBool32 primitiveFragmentShadingRateWithMultipleViewports + VkBool32 layeredShadingRateAttachments + VkBool32 fragmentShadingRateNonTrivialCombinerOps + VkExtent2D maxFragmentSize + uint32_t maxFragmentSizeAspectRatio + uint32_t maxFragmentShadingRateCoverageSamples + VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples + VkBool32 fragmentShadingRateWithShaderDepthStencilWrites + VkBool32 fragmentShadingRateWithSampleMask + VkBool32 fragmentShadingRateWithShaderSampleMask + VkBool32 fragmentShadingRateWithConservativeRasterization + VkBool32 fragmentShadingRateWithFragmentShaderInterlock + VkBool32 fragmentShadingRateWithCustomSampleLocations + VkBool32 fragmentShadingRateStrictMultiplyCombiner + + + VkStructureType sType + void* pNext + VkSampleCountFlags sampleCounts + VkExtent2D fragmentSize + + + VkStructureTypesType + void* pNext + VkBool32 shaderTerminateInvocation + + + VkStructureType sType + void* pNext + VkBool32 fragmentShadingRateEnums + VkBool32 supersampleFragmentShadingRates + VkBool32 noInvocationFragmentShadingRates + + + VkStructureType sType + void* pNext + VkSampleCountFlagBits maxFragmentShadingRateInvocationCount + + + VkStructureType sType + const void* pNext + VkFragmentShadingRateTypeNV shadingRateType + VkFragmentShadingRateNV shadingRate + VkFragmentShadingRateCombinerOpKHR combinerOps[2] + + + VkStructureType sType + const void* pNext + VkDeviceSize accelerationStructureSize + VkDeviceSize updateScratchSize + VkDeviceSize buildScratchSize + + + VkStructureType sType + void* pNext + VkBool32 mutableDescriptorType + + + uint32_t descriptorTypeCount + const VkDescriptorType* pDescriptorTypes + + + VkStructureType sType + const void* pNext + uint32_t mutableDescriptorTypeListCount + const VkMutableDescriptorTypeListVALVE* pMutableDescriptorTypeLists + + + VkStructureType sType + void* pNext + VkBool32 depthClipControl + + + VkStructureType sType + const void* pNext + VkBool32 negativeOneToOne + + + VkStructureType sType + void* pNext + VkBool32 vertexInputDynamicState + + + VkStructureType sType + void* pNext + VkBool32 externalMemoryRDMA + + + VkStructureTypesType + void* pNext + uint32_t binding + uint32_t stride + VkVertexInputRate inputRate + uint32_t divisor + + + VkStructureTypesType + void* pNext + uint32_t locationlocation of the shader vertex attrib + uint32_t bindingVertex buffer binding id + VkFormat formatformat of source data + uint32_t offsetOffset of first element in bytes from base of vertex + + + VkStructureType sType + void* pNext + VkBool32 colorWriteEnable + + + VkStructureType sType + const void* pNext + uint32_t attachmentCount# of pAttachments + const VkBool32* pColorWriteEnables + + + VkStructureType sType + const void* pNext + VkPipelineStageFlags2KHR srcStageMask + VkAccessFlags2KHR srcAccessMask + VkPipelineStageFlags2KHR dstStageMask + VkAccessFlags2KHR dstAccessMask + + + VkStructureType sType + const void* pNext + VkPipelineStageFlags2KHR srcStageMask + VkAccessFlags2KHR srcAccessMask + VkPipelineStageFlags2KHR dstStageMask + VkAccessFlags2KHR dstAccessMask + VkImageLayout oldLayout + VkImageLayout newLayout + uint32_t srcQueueFamilyIndex + uint32_t dstQueueFamilyIndex + VkImage image + VkImageSubresourceRange subresourceRange + + + VkStructureType sType + const void* pNext + VkPipelineStageFlags2KHR srcStageMask + VkAccessFlags2KHR srcAccessMask + VkPipelineStageFlags2KHR dstStageMask + VkAccessFlags2KHR dstAccessMask + uint32_t srcQueueFamilyIndex + uint32_t dstQueueFamilyIndex + VkBuffer buffer + VkDeviceSize offset + VkDeviceSize size + + + VkStructureType sType + const void* pNext + VkDependencyFlags dependencyFlags + uint32_t memoryBarrierCount + const VkMemoryBarrier2KHR* pMemoryBarriers + uint32_t bufferMemoryBarrierCount + const VkBufferMemoryBarrier2KHR* pBufferMemoryBarriers + uint32_t imageMemoryBarrierCount + const VkImageMemoryBarrier2KHR* pImageMemoryBarriers + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + uint64_t value + VkPipelineStageFlags2KHR stageMask + uint32_t deviceIndex + + + VkStructureType sType + const void* pNext + VkCommandBuffer commandBuffer + uint32_t deviceMask + + + VkStructureType sType + const void* pNext + VkSubmitFlagsKHR flags + uint32_t waitSemaphoreInfoCount + const VkSemaphoreSubmitInfoKHR* pWaitSemaphoreInfos + uint32_t commandBufferInfoCount + const VkCommandBufferSubmitInfoKHR* pCommandBufferInfos + uint32_t signalSemaphoreInfoCount + const VkSemaphoreSubmitInfoKHR* pSignalSemaphoreInfos + + + VkStructureType sType + void* pNext + VkPipelineStageFlags2KHR checkpointExecutionStageMask + + + VkStructureType sType + void* pNext + VkPipelineStageFlags2KHR stage + void* pCheckpointMarker + + + VkStructureType sType + void* pNext + VkBool32 synchronization2 + + + VkStructureTypesType + void* pNext + VkBool32 deviceNoDynamicHostAllocations + VkBool32 deviceDestroyFreesMemory + VkBool32 commandPoolMultipleCommandBuffersRecording + VkBool32 commandPoolResetCommandBuffer + VkBool32 commandBufferSimultaneousUse + VkBool32 secondaryCommandBufferNullOrImagelessFramebuffer + VkBool32 recycleDescriptorSetMemory + VkBool32 recyclePipelineMemory + uint32_t maxRenderPassSubpasses + uint32_t maxRenderPassDependencies + uint32_t maxSubpassInputAttachments + uint32_t maxSubpassPreserveAttachments + uint32_t maxFramebufferAttachments + uint32_t maxDescriptorSetLayoutBindings + uint32_t maxQueryFaultCount + uint32_t maxCallbackFaultCount + uint32_t maxCommandPoolCommandBuffers + VkDeviceSize maxCommandBufferSize + + + VkStructureType sType + const void* pNext + VkDeviceSize poolEntrySize + uint32_t poolEntryCount + + + VkStructureType sType + const void* pNext + uint32_t pipelineCacheCreateInfoCount + const VkPipelineCacheCreateInfo* pPipelineCacheCreateInfos + uint32_t pipelinePoolSizeCount + const VkPipelinePoolSize* pPipelinePoolSizes + uint32_t semaphoreRequestCount + uint32_t commandBufferRequestCount + uint32_t fenceRequestCount + uint32_t deviceMemoryRequestCount + uint32_t bufferRequestCount + uint32_t imageRequestCount + uint32_t eventRequestCount + uint32_t queryPoolRequestCount + uint32_t bufferViewRequestCount + uint32_t imageViewRequestCount + uint32_t layeredImageViewRequestCount + uint32_t pipelineCacheRequestCount + uint32_t pipelineLayoutRequestCount + uint32_t renderPassRequestCount + uint32_t graphicsPipelineRequestCount + uint32_t computePipelineRequestCount + uint32_t descriptorSetLayoutRequestCount + uint32_t samplerRequestCount + uint32_t descriptorPoolRequestCount + uint32_t descriptorSetRequestCount + uint32_t framebufferRequestCount + uint32_t commandPoolRequestCount + uint32_t samplerYcbcrConversionRequestCount + uint32_t surfaceRequestCount + uint32_t swapchainRequestCount + uint32_t displayModeRequestCount + uint32_t subpassDescriptionRequestCount + uint32_t attachmentDescriptionRequestCount + uint32_t descriptorSetLayoutBindingRequestCount + uint32_t descriptorSetLayoutBindingLimit + uint32_t maxImageViewMipLevels + uint32_t maxImageViewArrayLayers + uint32_t maxLayeredImageViewMipLevels + uint32_t maxOcclusionQueriesPerPool + uint32_t maxPipelineStatisticsQueriesPerPool + uint32_t maxTimestampQueriesPerPool + uint32_t maxImmutableSamplersPerDescriptorSetLayout + + + VkStructureType sType + const void* pNext + VkDeviceSize commandPoolReservedSize + uint32_t commandPoolMaxCommandBuffers + + + VkStructureType sType + void* pNext + VkDeviceSize commandPoolAllocated + VkDeviceSize commandPoolReservedSize + VkDeviceSize commandBufferAllocated + + + VkStructureType sType + void* pNext + VkBool32 shaderAtomicInstructions + + + VkStructureTypesType + void* pNext + VkVideoCodecOperationFlagsKHR videoCodecOperations + + + VkStructureTypesType + void* pNext + uint32_t profileCount + const VkVideoProfileKHR* pProfiles + + + VkStructureTypesType + void* pNext + VkImageUsageFlags imageUsage + const VkVideoProfilesKHR* pVideoProfiles + + + VkStructureTypesType + void* pNext + VkFormat format + + + VkStructureTypesType + void* pNext + VkVideoCodecOperationFlagBitsKHR videoCodecOperation + VkVideoChromaSubsamplingFlagsKHR chromaSubsampling + VkVideoComponentBitDepthFlagsKHR lumaBitDepth + VkVideoComponentBitDepthFlagsKHR chromaBitDepth + + + VkStructureTypesType + void* pNext + VkVideoCapabilityFlagsKHR capabilityFlags + VkDeviceSize minBitstreamBufferOffsetAlignment + VkDeviceSize minBitstreamBufferSizeAlignment + VkExtent2D videoPictureExtentGranularity + VkExtent2D minExtent + VkExtent2D maxExtent + uint32_t maxReferencePicturesSlotsCount + uint32_t maxReferencePicturesActiveCount + + + VkStructureTypesType + const void* pNext + uint32_t memoryBindIndex + VkMemoryRequirements2* pMemoryRequirements + + + VkStructureTypesType + const void* pNext + uint32_t memoryBindIndex + VkDeviceMemory memory + VkDeviceSize memoryOffset + VkDeviceSize memorySize + + + VkStructureTypesType + const void* pNext + VkOffset2D codedOffsetThe offset to be used for the picture resource, currently only used in field mode + VkExtent2D codedExtentThe extent to be used for the picture resource + uint32_t baseArrayLayerTThe first array layer to be accessed for the Decode or Encode Operations + VkImageView imageViewBindingThe ImageView binding of the resource + + + VkStructureTypesType + const void* pNext + int8_t slotIndexThe reference slot index + const VkVideoPictureResourceKHR* pPictureResourceThe reference picture resource + + + VkStructureTypesType + const void* pNext + VkVideoDecodeFlagsKHR flags + VkOffset2D codedOffset + VkExtent2D codedExtent + VkBuffer srcBuffer + VkDeviceSize srcBufferOffset + VkDeviceSize srcBufferRange + VkVideoPictureResourceKHR dstPictureResource + const VkVideoReferenceSlotKHR* pSetupReferenceSlot + uint32_t referenceSlotCount + const VkVideoReferenceSlotKHR* pReferenceSlots + + Video Decode Codec Standard specific structures + #include "vk_video/vulkan_video_codec_h264std.h" + + + + + + + + + + + + + + + + + + + #include "vk_video/vulkan_video_codec_h264std_decode.h" + + + + + + + + + VkStructureTypesType + const void* pNext + StdVideoH264ProfileIdc stdProfileIdc + VkVideoDecodeH264PictureLayoutFlagsEXT pictureLayout + + + VkStructureTypesType + void* pNext + uint32_t maxLevel + VkOffset2D fieldOffsetGranularity + VkExtensionProperties stdExtensionVersion + + + VkStructureTypesType + const void* pNext + VkVideoDecodeH264CreateFlagsEXT flags + const VkExtensionProperties* pStdExtensionVersion + + + + + VkStructureTypesType + const void* pNext + uint32_t spsStdCount + const StdVideoH264SequenceParameterSet* pSpsStd + uint32_t ppsStdCount + const StdVideoH264PictureParameterSet* pPpsStdList of Picture Parameters associated with the spsStd, above + + + VkStructureTypesType + const void* pNext + uint32_t maxSpsStdCount + uint32_t maxPpsStdCount + const VkVideoDecodeH264SessionParametersAddInfoEXT* pParametersAddInfo + + + VkStructureTypesType + const void* pNext + const StdVideoDecodeH264PictureInfo* pStdPictureInfo + uint32_t slicesCount + const uint32_t* pSlicesDataOffsets + + + VkStructureTypesType + const void* pNext + const StdVideoDecodeH264ReferenceInfo* pStdReferenceInfo + + + VkStructureTypesType + const void*pNext + const StdVideoDecodeH264Mvc* pStdMvc + + #include "vk_video/vulkan_video_codec_h265std.h" + + + + + + + + + + + + + + + + + + + #include "vk_video/vulkan_video_codec_h265std_decode.h" + + + + + + VkStructureTypesType + const void* pNext + StdVideoH265ProfileIdc stdProfileIdc + + + VkStructureTypesType + void* pNext + uint32_t maxLevel + VkExtensionProperties stdExtensionVersion + + + VkStructureTypesType + const void* pNext + VkVideoDecodeH265CreateFlagsEXT flags + const VkExtensionProperties* pStdExtensionVersion + + + VkStructureTypesType + const void* pNext + uint32_t spsStdCount + const StdVideoH265SequenceParameterSet* pSpsStd + uint32_t ppsStdCount + const StdVideoH265PictureParameterSet* pPpsStdList of Picture Parameters associated with the spsStd, above + + + VkStructureTypesType + const void* pNext + uint32_t maxSpsStdCount + uint32_t maxPpsStdCount + const VkVideoDecodeH265SessionParametersAddInfoEXT* pParametersAddInfo + + + VkStructureTypesType + const void* pNext + StdVideoDecodeH265PictureInfo* pStdPictureInfo + uint32_t slicesCount + const uint32_t* pSlicesDataOffsets + + + VkStructureTypesType + const void* pNext + const StdVideoDecodeH265ReferenceInfo* pStdReferenceInfo + + + VkStructureTypesType + const void* pNext + uint32_t queueFamilyIndex + VkVideoSessionCreateFlagsKHR flags + const VkVideoProfileKHR* pVideoProfile + VkFormat pictureFormat + VkExtent2D maxCodedExtent + VkFormat referencePicturesFormat + uint32_t maxReferencePicturesSlotsCount + uint32_t maxReferencePicturesActiveCount + + + VkStructureTypesType + const void* pNext + VkVideoSessionParametersKHR videoSessionParametersTemplate + VkVideoSessionKHR videoSession + + + VkStructureTypesType + const void* pNext + uint32_t updateSequenceCount + + + VkStructureTypesType + const void* pNext + VkVideoBeginCodingFlagsKHR flags + VkVideoCodingQualityPresetFlagsKHR codecQualityPreset + VkVideoSessionKHR videoSession + VkVideoSessionParametersKHR videoSessionParameters + uint32_t referenceSlotCount + const VkVideoReferenceSlotKHR* pReferenceSlots + + + VkStructureTypesType + const void* pNext + VkVideoEndCodingFlagsKHR flags + + + VkStructureTypesType + const void* pNext + VkVideoCodingControlFlagsKHR flags + + + VkStructureTypesType + const void* pNext + VkVideoEncodeFlagsKHR flags + uint32_t qualityLevel + VkExtent2D codedExtent + VkBuffer dstBitstreamBuffer + VkDeviceSize dstBitstreamBufferOffset + VkDeviceSize dstBitstreamBufferMaxRange + VkVideoPictureResourceKHR srcPictureResource + const VkVideoReferenceSlotKHR* pSetupReferenceSlot + uint32_t referenceSlotCount + const VkVideoReferenceSlotKHR* pReferenceSlots + uint32_t precedingExternallyEncodedBytes + + + VkStructureTypesType + const void* pNext + VkVideoEncodeRateControlFlagsKHR flags + VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode + uint8_t layerCount + const VkVideoEncodeRateControlLayerInfoKHR* pLayerConfigs + + + VkStructureTypesType + const void* pNext + uint32_t averageBitrate + uint32_t maxBitrate + uint32_t frameRateNumerator + uint32_t frameRateDenominator + uint32_t virtualBufferSizeInMs + uint32_t initialVirtualBufferSizeInMs + + + VkStructureTypesType + const void* pNext + VkVideoEncodeH264CapabilityFlagsEXT flags + VkVideoEncodeH264InputModeFlagsEXT inputModeFlags + VkVideoEncodeH264OutputModeFlagsEXT outputModeFlags + VkExtent2D minPictureSizeInMbs + VkExtent2D maxPictureSizeInMbs + VkExtent2D inputImageDataAlignment + uint8_t maxNumL0ReferenceForP + uint8_t maxNumL0ReferenceForB + uint8_t maxNumL1Reference + uint8_t qualityLevelCount + VkExtensionProperties stdExtensionVersion + + + VkStructureTypesType + const void* pNext + VkVideoEncodeH264CreateFlagsEXT flags + VkExtent2D maxPictureSizeInMbs + const VkExtensionProperties* pStdExtensionVersion + + #include "vk_video/vulkan_video_codec_h264std_encode.h" + + + + + + + + + + VkStructureTypesType + const void* pNext + uint32_t spsStdCount + const StdVideoH264SequenceParameterSet* pSpsStd + uint32_t ppsStdCount + const StdVideoH264PictureParameterSet* pPpsStdList of Picture Parameters associated with the spsStd, above + + + VkStructureTypesType + const void* pNext + uint32_t maxSpsStdCount + uint32_t maxPpsStdCount + const VkVideoEncodeH264SessionParametersAddInfoEXT* pParametersAddInfo + + + VkStructureTypesType + const void* pNext + int8_t slotIndex + const StdVideoEncodeH264PictureInfo* pStdPictureInfo + + + VkStructureTypesType + const void* pNext + uint8_t refDefaultFinalList0EntryCount + const VkVideoEncodeH264DpbSlotInfoEXT* pRefDefaultFinalList0Entries + uint8_t refDefaultFinalList1EntryCount + const VkVideoEncodeH264DpbSlotInfoEXT* pRefDefaultFinalList1Entries + uint32_t naluSliceEntryCount + const VkVideoEncodeH264NaluSliceEXT* pNaluSliceEntries + const VkVideoEncodeH264DpbSlotInfoEXT* pCurrentPictureInfo + + + VkStructureTypesType + const void* pNext + uint8_t spsId + VkBool32 emitSpsEnable + uint32_t ppsIdEntryCount + const uint8_t* ppsIdEntries + + + VkStructureTypesType + const void* pNext + StdVideoH264ProfileIdc stdProfileIdc + + + VkStructureTypesType + const void* pNext + const StdVideoEncodeH264SliceHeader* pSliceHeaderStd + uint32_t mbCount + uint8_t refFinalList0EntryCount + const VkVideoEncodeH264DpbSlotInfoEXT* pRefFinalList0Entries + uint8_t refFinalList1EntryCount + const VkVideoEncodeH264DpbSlotInfoEXT* pRefFinalList1Entries + + + VkStructureTypesType + const void* pNext + uint32_t gopFrameCount + uint32_t idrPeriod + uint32_t consecutiveBFrameCount + VkVideoEncodeH264RateControlStructureFlagBitsEXT rateControlStructure + + + int32_t qpI + int32_t qpP + int32_t qpB + + + uint32_t frameISize + uint32_t framePSize + uint32_t frameBSize + + + VkStructureTypesType + const void* pNext + uint8_t temporalLayerId + VkBool32 useInitialRcQp + VkVideoEncodeH264QpEXT initialRcQp + VkBool32 useMinQp + VkVideoEncodeH264QpEXT minQp + VkBool32 useMaxQp + VkVideoEncodeH264QpEXT maxQp + VkBool32 useMaxFrameSize + VkVideoEncodeH264FrameSizeEXT maxFrameSize + + + VkStructureTypesType + const void* pNext + VkVideoEncodeH265CapabilityFlagsEXT flags + VkVideoEncodeH265InputModeFlagsEXT inputModeFlags + VkVideoEncodeH265OutputModeFlagsEXT outputModeFlags + VkVideoEncodeH265CtbSizeFlagsEXT ctbSizes + VkExtent2D inputImageDataAlignment + uint8_t maxNumL0ReferenceForP + uint8_t maxNumL0ReferenceForB + uint8_t maxNumL1Reference + uint8_t maxNumSubLayers + uint8_t qualityLevelCount + VkExtensionProperties stdExtensionVersion + + + VkStructureTypesType + const void* pNext + VkVideoEncodeH265CreateFlagsEXT flags + const VkExtensionProperties* pStdExtensionVersion + + #include "vk_video/vulkan_video_codec_h265std_encode.h" + + + + + + + + + + VkStructureTypesType + const void* pNext + uint32_t vpsStdCount + const StdVideoH265VideoParameterSet* pVpsStd + uint32_t spsStdCount + const StdVideoH265SequenceParameterSet* pSpsStd + uint32_t ppsStdCount + const StdVideoH265PictureParameterSet* pPpsStdList of Picture Parameters associated with the spsStd, above + + + VkStructureTypesType + const void* pNext + uint32_t maxVpsStdCount + uint32_t maxSpsStdCount + uint32_t maxPpsStdCount + const VkVideoEncodeH265SessionParametersAddInfoEXT* pParametersAddInfo + + + VkStructureTypesType + const void* pNext + const VkVideoEncodeH265ReferenceListsEXT* pReferenceFinalLists + uint32_t naluSliceEntryCount + const VkVideoEncodeH265NaluSliceEXT* pNaluSliceEntries + const StdVideoEncodeH265PictureInfo* pCurrentPictureInfo + + + VkStructureTypesType + const void* pNext + uint8_t vpsId + uint8_t spsId + VkBool32 emitVpsEnable + VkBool32 emitSpsEnable + uint32_t ppsIdEntryCount + const uint8_t* ppsIdEntries + + + VkStructureTypesType + const void* pNext + uint32_t ctbCount + const VkVideoEncodeH265ReferenceListsEXT* pReferenceFinalLists + const StdVideoEncodeH265SliceHeader* pSliceHeaderStd + + + VkStructureTypesType + const void* pNext + uint32_t gopFrameCount + uint32_t idrPeriod + uint32_t consecutiveBFrameCount + VkVideoEncodeH265RateControlStructureFlagBitsEXT rateControlStructure + + + int32_t qpI + int32_t qpP + int32_t qpB + + + uint32_t frameISize + uint32_t framePSize + uint32_t frameBSize + + + VkStructureTypesType + const void* pNext + uint8_t temporalId + VkBool32 useInitialRcQp + VkVideoEncodeH265QpEXT initialRcQp + VkBool32 useMinQp + VkVideoEncodeH265QpEXT minQp + VkBool32 useMaxQp + VkVideoEncodeH265QpEXT maxQp + VkBool32 useMaxFrameSize + VkVideoEncodeH265FrameSizeEXT maxFrameSize + + + VkStructureTypesType + const void* pNext + StdVideoH265ProfileIdc stdProfileIdc + + + VkStructureTypesType + const void* pNext + int8_t slotIndex + const StdVideoEncodeH265ReferenceInfo* pStdReferenceInfo + + + VkStructureTypesType + const void* pNext + uint8_t referenceList0EntryCount + const VkVideoEncodeH265DpbSlotInfoEXT* pReferenceList0Entries + uint8_t referenceList1EntryCount + const VkVideoEncodeH265DpbSlotInfoEXT* pReferenceList1Entries + const StdVideoEncodeH265ReferenceModifications* pReferenceModifications + + + VkStructureType sType + void* pNext + VkBool32 inheritedViewportScissor2D + + + VkStructureType sType + const void* pNext + VkBool32 viewportScissor2D + uint32_t viewportDepthCount + const VkViewport* pViewportDepths + + + VkStructureType sType + void* pNext + VkBool32 ycbcr2plane444Formats + + + VkStructureType sType + void* pNext + VkBool32 provokingVertexLast + VkBool32 transformFeedbackPreservesProvokingVertex + + + VkStructureType sType + void* pNext + VkBool32 provokingVertexModePerPipeline + VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex + + + VkStructureType sType + const void* pNext + VkProvokingVertexModeEXT provokingVertexMode + + + VkStructureType sType + const void* pNext + size_t dataSize + const void* pData + + + VkStructureType sType + const void* pNext + VkCuModuleNVX module + const char* pName + + + VkStructureType sType + const void* pNext + VkCuFunctionNVX function + uint32_t gridDimX + uint32_t gridDimY + uint32_t gridDimZ + uint32_t blockDimX + uint32_t blockDimY + uint32_t blockDimZ + uint32_t sharedMemBytes + size_t paramCount + const void* const * pParams + size_t extraCount + const void* const * pExtras + + + VkStructureType sType + void* pNext + VkBool32 shaderIntegerDotProduct + + + VkStructureType sType + void* pNext + VkBool32 integerDotProduct8BitUnsignedAccelerated + VkBool32 integerDotProduct8BitSignedAccelerated + VkBool32 integerDotProduct8BitMixedSignednessAccelerated + VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated + VkBool32 integerDotProduct4x8BitPackedSignedAccelerated + VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated + VkBool32 integerDotProduct16BitUnsignedAccelerated + VkBool32 integerDotProduct16BitSignedAccelerated + VkBool32 integerDotProduct16BitMixedSignednessAccelerated + VkBool32 integerDotProduct32BitUnsignedAccelerated + VkBool32 integerDotProduct32BitSignedAccelerated + VkBool32 integerDotProduct32BitMixedSignednessAccelerated + VkBool32 integerDotProduct64BitUnsignedAccelerated + VkBool32 integerDotProduct64BitSignedAccelerated + VkBool32 integerDotProduct64BitMixedSignednessAccelerated + VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated + VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated + VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated + VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated + + + VkStructureType sType + void* pNext + VkBool32 hasPrimary + VkBool32 hasRender + int64_t primaryMajor + int64_t primaryMinor + int64_t renderMajor + int64_t renderMinor + + + VkStructureType sType + void* pNext + VkBool32 rayTracingMotionBlur + VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect + + + + VkStructureType sType + const void* pNext + VkDeviceOrHostAddressConstKHR vertexData + + + VkStructureType sType + const void* pNext + uint32_t maxInstances + VkAccelerationStructureMotionInfoFlagsNV flags + + + float sx + float a + float b + float pvx + float sy + float c + float pvy + float sz + float pvz + float qx + float qy + float qz + float qw + float tx + float ty + float tz + + + The bitfields in this structure are non-normative since bitfield ordering is implementation-defined in C. The specification defines the normative layout. + VkSRTDataNV transformT0 + VkSRTDataNV transformT1 + uint32_t instanceCustomIndex:24 + uint32_t mask:8 + uint32_t instanceShaderBindingTableRecordOffset:24 + VkGeometryInstanceFlagsKHR flags:8 + uint64_t accelerationStructureReference + + + The bitfields in this structure are non-normative since bitfield ordering is implementation-defined in C. The specification defines the normative layout. + VkTransformMatrixKHR transformT0 + VkTransformMatrixKHR transformT1 + uint32_t instanceCustomIndex:24 + uint32_t mask:8 + uint32_t instanceShaderBindingTableRecordOffset:24 + VkGeometryInstanceFlagsKHR flags:8 + uint64_t accelerationStructureReference + + + VkAccelerationStructureInstanceKHR staticInstance + VkAccelerationStructureMatrixMotionInstanceNV matrixMotionInstance + VkAccelerationStructureSRTMotionInstanceNV srtMotionInstance + + + VkAccelerationStructureMotionInstanceTypeNV type + VkAccelerationStructureMotionInstanceFlagsNV flags + VkAccelerationStructureMotionInstanceDataNV data + + typedef void* VkRemoteAddressNV; + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + VkExternalMemoryHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + VkBufferCollectionFUCHSIA collection + uint32_t index + + + VkStructureType sType + const void* pNext + VkBufferCollectionFUCHSIA collection + uint32_t index + + + VkStructureType sType + const void* pNext + VkBufferCollectionFUCHSIA collection + uint32_t index + + + VkStructureType sType + const void* pNext + zx_handle_t collectionToken + + + VkStructureType sType + void* pNext + uint32_t memoryTypeBits + uint32_t bufferCount + uint32_t createInfoIndex + uint64_t sysmemPixelFormat + VkFormatFeatureFlags formatFeatures + VkSysmemColorSpaceFUCHSIA sysmemColorSpaceIndex + VkComponentMapping samplerYcbcrConversionComponents + VkSamplerYcbcrModelConversion suggestedYcbcrModel + VkSamplerYcbcrRange suggestedYcbcrRange + VkChromaLocation suggestedXChromaOffset + VkChromaLocation suggestedYChromaOffset + + + VkStructureType sType + const void* pNext + VkBufferCreateInfo createInfo + VkFormatFeatureFlags requiredFormatFeatures + VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints + + + VkStructureType sType + const void* pNext + uint32_t colorSpace + + + VkStructureType sType + const void* pNext + VkImageCreateInfo imageCreateInfo + VkFormatFeatureFlags requiredFormatFeatures + VkImageFormatConstraintsFlagsFUCHSIA flags + uint64_t sysmemPixelFormat + uint32_t colorSpaceCount + const VkSysmemColorSpaceFUCHSIA* pColorSpaces + + + VkStructureType sType + const void* pNext + uint32_t formatConstraintsCount + const VkImageFormatConstraintsInfoFUCHSIA* pFormatConstraints + VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints + VkImageConstraintsInfoFlagsFUCHSIA flags + + + VkStructureType sType + const void* pNext + uint32_t minBufferCount + uint32_t maxBufferCount + uint32_t minBufferCountForCamping + uint32_t minBufferCountForDedicatedSlack + uint32_t minBufferCountForSharedSlack + + + VkStructureType sType + void* pNext + VkBool32 formatRgba10x6WithoutYCbCrSampler + + + VkStructureType sType + void* pNext + VkFormatFeatureFlags2KHR linearTilingFeatures + VkFormatFeatureFlags2KHR optimalTilingFeatures + VkFormatFeatureFlags2KHR bufferFeatures + + + VkStructureType sType + void* pNext + uint32_t drmFormatModifierCount + VkDrmFormatModifierProperties2EXT* pDrmFormatModifierProperties + + + uint64_t drmFormatModifier + uint32_t drmFormatModifierPlaneCount + VkFormatFeatureFlags2KHR drmFormatModifierTilingFeatures + + + VkStructureType sType + void* pNext + VkFormat format + uint64_t externalFormat + VkFormatFeatureFlags2KHR formatFeatures + VkComponentMapping samplerYcbcrConversionComponents + VkSamplerYcbcrModelConversion suggestedYcbcrModel + VkSamplerYcbcrRange suggestedYcbcrRange + VkChromaLocation suggestedXChromaOffset + VkChromaLocation suggestedYChromaOffset + + + VkStructureType sType + const void* pNext + uint32_t viewMask + uint32_t colorAttachmentCount + const VkFormat* pColorAttachmentFormats + VkFormat depthAttachmentFormat + VkFormat stencilAttachmentFormat + + + VkStructureType sType + const void* pNext + VkRenderingFlagsKHR flags + VkRect2D renderArea + uint32_t layerCount + uint32_t viewMask + uint32_t colorAttachmentCount + const VkRenderingAttachmentInfoKHR* pColorAttachments + const VkRenderingAttachmentInfoKHR* pDepthAttachment + const VkRenderingAttachmentInfoKHR* pStencilAttachment + + + VkStructureType sType + const void* pNext + VkImageView imageView + VkImageLayout imageLayout + VkResolveModeFlagBits resolveMode + VkImageView resolveImageView + VkImageLayout resolveImageLayout + VkAttachmentLoadOp loadOp + VkAttachmentStoreOp storeOp + VkClearValue clearValue + + + VkStructureType sType + const void* pNext + VkImageView imageView + VkImageLayout imageLayout + VkExtent2D shadingRateAttachmentTexelSize + + + VkStructureType sType + const void* pNext + VkImageView imageView + VkImageLayout imageLayout + + + VkStructureType sType + void* pNext + VkBool32 dynamicRendering + + + VkStructureType sType + const void* pNext + VkRenderingFlagsKHR flags + uint32_t viewMask + uint32_t colorAttachmentCount + uint32_t colorAttachmentCount + const VkFormat* pColorAttachmentFormats + VkFormat depthAttachmentFormat + VkFormat stencilAttachmentFormat + VkSampleCountFlagBits rasterizationSamples + + + VkStructureType sType + const void* pNext + uint32_t colorAttachmentCount + const VkSampleCountFlagBits* pColorAttachmentSamples + VkSampleCountFlagBits depthStencilAttachmentSamples + + + + VkStructureType sType + const void* pNext + VkBool32 perViewAttributes + VkBool32 perViewAttributesPositionXOnly + + + VkStructureType sType + void* pNext + VkBool32 minLod + + + VkStructureType sType + const void* pNext + float minLod + + + VkStructureType sType + const void* pNext + VkBool32 rasterizationOrderColorAttachmentAccess + VkBool32 rasterizationOrderDepthAttachmentAccess + VkBool32 rasterizationOrderStencilAttachmentAccess + + + Vulkan enumerant (token) definitions + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Unlike OpenGL, most tokens in Vulkan are actual typed enumerants in + their own numeric namespaces. The "name" attribute is the C enum + type name, and is pulled in from a type tag definition above + (slightly clunky, but retains the type / enum distinction). "type" + attributes of "enum" or "bitmask" indicate that these values should + be generated inside an appropriate definition. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + value="4" reserved for VK_KHR_sampler_mirror_clamp_to_edge + enum VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE; do not + alias! + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Return codes (positive values) + + + + + + + Error codes (negative values) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Flags + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + WSI Extensions + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Vendor IDs are now represented as enums instead of the old + <vendorids> tag, allowing them to be included in the + API headers. + + + + + + + + + + Driver IDs are now represented as enums instead of the old + <driverids> tag, allowing them to be included in the + API headers. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + VkResult vkCreateInstance + const VkInstanceCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkInstance* pInstance + + + void vkDestroyInstance + VkInstance instance + const VkAllocationCallbacks* pAllocator + + all sname:VkPhysicalDevice objects enumerated from pname:instance + + + + VkResult vkEnumeratePhysicalDevices + VkInstance instance + uint32_t* pPhysicalDeviceCount + VkPhysicalDevice* pPhysicalDevices + + + PFN_vkVoidFunction vkGetDeviceProcAddr + VkDevice device + const char* pName + + + PFN_vkVoidFunction vkGetInstanceProcAddr + VkInstance instance + const char* pName + + + void vkGetPhysicalDeviceProperties + VkPhysicalDevice physicalDevice + VkPhysicalDeviceProperties* pProperties + + + void vkGetPhysicalDeviceQueueFamilyProperties + VkPhysicalDevice physicalDevice + uint32_t* pQueueFamilyPropertyCount + VkQueueFamilyProperties* pQueueFamilyProperties + + + void vkGetPhysicalDeviceMemoryProperties + VkPhysicalDevice physicalDevice + VkPhysicalDeviceMemoryProperties* pMemoryProperties + + + void vkGetPhysicalDeviceFeatures + VkPhysicalDevice physicalDevice + VkPhysicalDeviceFeatures* pFeatures + + + void vkGetPhysicalDeviceFormatProperties + VkPhysicalDevice physicalDevice + VkFormat format + VkFormatProperties* pFormatProperties + + + VkResult vkGetPhysicalDeviceImageFormatProperties + VkPhysicalDevice physicalDevice + VkFormat format + VkImageType type + VkImageTiling tiling + VkImageUsageFlags usage + VkImageCreateFlags flags + VkImageFormatProperties* pImageFormatProperties + + + VkResult vkCreateDevice + VkPhysicalDevice physicalDevice + const VkDeviceCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDevice* pDevice + + + void vkDestroyDevice + VkDevice device + const VkAllocationCallbacks* pAllocator + + all sname:VkQueue objects created from pname:device + + + + VkResult vkEnumerateInstanceVersion + uint32_t* pApiVersion + + + VkResult vkEnumerateInstanceLayerProperties + uint32_t* pPropertyCount + VkLayerProperties* pProperties + + + VkResult vkEnumerateInstanceExtensionProperties + const char* pLayerName + uint32_t* pPropertyCount + VkExtensionProperties* pProperties + + + VkResult vkEnumerateDeviceLayerProperties + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkLayerProperties* pProperties + + + VkResult vkEnumerateDeviceExtensionProperties + VkPhysicalDevice physicalDevice + const char* pLayerName + uint32_t* pPropertyCount + VkExtensionProperties* pProperties + + + void vkGetDeviceQueue + VkDevice device + uint32_t queueFamilyIndex + uint32_t queueIndex + VkQueue* pQueue + + + VkResult vkQueueSubmit + VkQueue queue + uint32_t submitCount + const VkSubmitInfo* pSubmits + VkFence fence + + + VkResult vkQueueWaitIdle + VkQueue queue + + + VkResult vkDeviceWaitIdle + VkDevice device + + all sname:VkQueue objects created from pname:device + + + + VkResult vkAllocateMemory + VkDevice device + const VkMemoryAllocateInfo* pAllocateInfo + const VkAllocationCallbacks* pAllocator + VkDeviceMemory* pMemory + + + void vkFreeMemory + VkDevice device + VkDeviceMemory memory + const VkAllocationCallbacks* pAllocator + + + VkResult vkMapMemory + VkDevice device + VkDeviceMemory memory + VkDeviceSize offset + VkDeviceSize size + VkMemoryMapFlags flags + void** ppData + + + void vkUnmapMemory + VkDevice device + VkDeviceMemory memory + + + VkResult vkFlushMappedMemoryRanges + VkDevice device + uint32_t memoryRangeCount + const VkMappedMemoryRange* pMemoryRanges + + + VkResult vkInvalidateMappedMemoryRanges + VkDevice device + uint32_t memoryRangeCount + const VkMappedMemoryRange* pMemoryRanges + + + void vkGetDeviceMemoryCommitment + VkDevice device + VkDeviceMemory memory + VkDeviceSize* pCommittedMemoryInBytes + + + void vkGetBufferMemoryRequirements + VkDevice device + VkBuffer buffer + VkMemoryRequirements* pMemoryRequirements + + + VkResult vkBindBufferMemory + VkDevice device + VkBuffer buffer + VkDeviceMemory memory + VkDeviceSize memoryOffset + + + void vkGetImageMemoryRequirements + VkDevice device + VkImage image + VkMemoryRequirements* pMemoryRequirements + + + VkResult vkBindImageMemory + VkDevice device + VkImage image + VkDeviceMemory memory + VkDeviceSize memoryOffset + + + void vkGetImageSparseMemoryRequirements + VkDevice device + VkImage image + uint32_t* pSparseMemoryRequirementCount + VkSparseImageMemoryRequirements* pSparseMemoryRequirements + + + void vkGetPhysicalDeviceSparseImageFormatProperties + VkPhysicalDevice physicalDevice + VkFormat format + VkImageType type + VkSampleCountFlagBits samples + VkImageUsageFlags usage + VkImageTiling tiling + uint32_t* pPropertyCount + VkSparseImageFormatProperties* pProperties + + + VkResult vkQueueBindSparse + VkQueue queue + uint32_t bindInfoCount + const VkBindSparseInfo* pBindInfo + VkFence fence + + + VkResult vkCreateFence + VkDevice device + const VkFenceCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkFence* pFence + + + void vkDestroyFence + VkDevice device + VkFence fence + const VkAllocationCallbacks* pAllocator + + + VkResult vkResetFences + VkDevice device + uint32_t fenceCount + const VkFence* pFences + + + VkResult vkGetFenceStatus + VkDevice device + VkFence fence + + + VkResult vkWaitForFences + VkDevice device + uint32_t fenceCount + const VkFence* pFences + VkBool32 waitAll + uint64_t timeout + + + VkResult vkCreateSemaphore + VkDevice device + const VkSemaphoreCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSemaphore* pSemaphore + + + void vkDestroySemaphore + VkDevice device + VkSemaphore semaphore + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateEvent + VkDevice device + const VkEventCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkEvent* pEvent + + + void vkDestroyEvent + VkDevice device + VkEvent event + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetEventStatus + VkDevice device + VkEvent event + + + VkResult vkSetEvent + VkDevice device + VkEvent event + + + VkResult vkResetEvent + VkDevice device + VkEvent event + + + VkResult vkCreateQueryPool + VkDevice device + const VkQueryPoolCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkQueryPool* pQueryPool + + + void vkDestroyQueryPool + VkDevice device + VkQueryPool queryPool + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetQueryPoolResults + VkDevice device + VkQueryPool queryPool + uint32_t firstQuery + uint32_t queryCount + size_t dataSize + void* pData + VkDeviceSize stride + VkQueryResultFlags flags + + + void vkResetQueryPool + VkDevice device + VkQueryPool queryPool + uint32_t firstQuery + uint32_t queryCount + + + + VkResult vkCreateBuffer + VkDevice device + const VkBufferCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkBuffer* pBuffer + + + void vkDestroyBuffer + VkDevice device + VkBuffer buffer + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateBufferView + VkDevice device + const VkBufferViewCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkBufferView* pView + + + void vkDestroyBufferView + VkDevice device + VkBufferView bufferView + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateImage + VkDevice device + const VkImageCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkImage* pImage + + + void vkDestroyImage + VkDevice device + VkImage image + const VkAllocationCallbacks* pAllocator + + + void vkGetImageSubresourceLayout + VkDevice device + VkImage image + const VkImageSubresource* pSubresource + VkSubresourceLayout* pLayout + + + VkResult vkCreateImageView + VkDevice device + const VkImageViewCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkImageView* pView + + + void vkDestroyImageView + VkDevice device + VkImageView imageView + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateShaderModule + VkDevice device + const VkShaderModuleCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkShaderModule* pShaderModule + + + void vkDestroyShaderModule + VkDevice device + VkShaderModule shaderModule + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreatePipelineCache + VkDevice device + const VkPipelineCacheCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkPipelineCache* pPipelineCache + + + void vkDestroyPipelineCache + VkDevice device + VkPipelineCache pipelineCache + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetPipelineCacheData + VkDevice device + VkPipelineCache pipelineCache + size_t* pDataSize + void* pData + + + VkResult vkMergePipelineCaches + VkDevice device + VkPipelineCache dstCache + uint32_t srcCacheCount + const VkPipelineCache* pSrcCaches + + + VkResult vkCreateGraphicsPipelines + VkDevice device + VkPipelineCache pipelineCache + uint32_t createInfoCount + const VkGraphicsPipelineCreateInfo* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkPipeline* pPipelines + + + VkResult vkCreateComputePipelines + VkDevice device + VkPipelineCache pipelineCache + uint32_t createInfoCount + const VkComputePipelineCreateInfo* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkPipeline* pPipelines + + + VkResult vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI + VkDevice device + VkRenderPass renderpass + VkExtent2D* pMaxWorkgroupSize + + + void vkDestroyPipeline + VkDevice device + VkPipeline pipeline + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreatePipelineLayout + VkDevice device + const VkPipelineLayoutCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkPipelineLayout* pPipelineLayout + + + void vkDestroyPipelineLayout + VkDevice device + VkPipelineLayout pipelineLayout + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateSampler + VkDevice device + const VkSamplerCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSampler* pSampler + + + void vkDestroySampler + VkDevice device + VkSampler sampler + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateDescriptorSetLayout + VkDevice device + const VkDescriptorSetLayoutCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDescriptorSetLayout* pSetLayout + + + void vkDestroyDescriptorSetLayout + VkDevice device + VkDescriptorSetLayout descriptorSetLayout + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateDescriptorPool + VkDevice device + const VkDescriptorPoolCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDescriptorPool* pDescriptorPool + + + void vkDestroyDescriptorPool + VkDevice device + VkDescriptorPool descriptorPool + const VkAllocationCallbacks* pAllocator + + + VkResult vkResetDescriptorPool + VkDevice device + VkDescriptorPool descriptorPool + VkDescriptorPoolResetFlags flags + + any sname:VkDescriptorSet objects allocated from pname:descriptorPool + + + + VkResult vkAllocateDescriptorSets + VkDevice device + const VkDescriptorSetAllocateInfo* pAllocateInfo + VkDescriptorSet* pDescriptorSets + + + VkResult vkFreeDescriptorSets + VkDevice device + VkDescriptorPool descriptorPool + uint32_t descriptorSetCount + const VkDescriptorSet* pDescriptorSets + + + void vkUpdateDescriptorSets + VkDevice device + uint32_t descriptorWriteCount + const VkWriteDescriptorSet* pDescriptorWrites + uint32_t descriptorCopyCount + const VkCopyDescriptorSet* pDescriptorCopies + + + VkResult vkCreateFramebuffer + VkDevice device + const VkFramebufferCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkFramebuffer* pFramebuffer + + + void vkDestroyFramebuffer + VkDevice device + VkFramebuffer framebuffer + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateRenderPass + VkDevice device + const VkRenderPassCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkRenderPass* pRenderPass + + + void vkDestroyRenderPass + VkDevice device + VkRenderPass renderPass + const VkAllocationCallbacks* pAllocator + + + void vkGetRenderAreaGranularity + VkDevice device + VkRenderPass renderPass + VkExtent2D* pGranularity + + + VkResult vkCreateCommandPool + VkDevice device + const VkCommandPoolCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkCommandPool* pCommandPool + + + void vkDestroyCommandPool + VkDevice device + VkCommandPool commandPool + const VkAllocationCallbacks* pAllocator + + + VkResult vkResetCommandPool + VkDevice device + VkCommandPool commandPool + VkCommandPoolResetFlags flags + + + VkResult vkAllocateCommandBuffers + VkDevice device + const VkCommandBufferAllocateInfo* pAllocateInfo + VkCommandBuffer* pCommandBuffers + + + void vkFreeCommandBuffers + VkDevice device + VkCommandPool commandPool + uint32_t commandBufferCount + const VkCommandBuffer* pCommandBuffers + + + VkResult vkBeginCommandBuffer + VkCommandBuffer commandBuffer + const VkCommandBufferBeginInfo* pBeginInfo + + the sname:VkCommandPool that pname:commandBuffer was allocated from + + + + VkResult vkEndCommandBuffer + VkCommandBuffer commandBuffer + + the sname:VkCommandPool that pname:commandBuffer was allocated from + + + + VkResult vkResetCommandBuffer + VkCommandBuffer commandBuffer + VkCommandBufferResetFlags flags + + the sname:VkCommandPool that pname:commandBuffer was allocated from + + + + void vkCmdBindPipeline + VkCommandBuffer commandBuffer + VkPipelineBindPoint pipelineBindPoint + VkPipeline pipeline + + + void vkCmdSetViewport + VkCommandBuffer commandBuffer + uint32_t firstViewport + uint32_t viewportCount + const VkViewport* pViewports + + + void vkCmdSetScissor + VkCommandBuffer commandBuffer + uint32_t firstScissor + uint32_t scissorCount + const VkRect2D* pScissors + + + void vkCmdSetLineWidth + VkCommandBuffer commandBuffer + float lineWidth + + + void vkCmdSetDepthBias + VkCommandBuffer commandBuffer + float depthBiasConstantFactor + float depthBiasClamp + float depthBiasSlopeFactor + + + void vkCmdSetBlendConstants + VkCommandBuffer commandBuffer + const float blendConstants[4] + + + void vkCmdSetDepthBounds + VkCommandBuffer commandBuffer + float minDepthBounds + float maxDepthBounds + + + void vkCmdSetStencilCompareMask + VkCommandBuffer commandBuffer + VkStencilFaceFlags faceMask + uint32_t compareMask + + + void vkCmdSetStencilWriteMask + VkCommandBuffer commandBuffer + VkStencilFaceFlags faceMask + uint32_t writeMask + + + void vkCmdSetStencilReference + VkCommandBuffer commandBuffer + VkStencilFaceFlags faceMask + uint32_t reference + + + void vkCmdBindDescriptorSets + VkCommandBuffer commandBuffer + VkPipelineBindPoint pipelineBindPoint + VkPipelineLayout layout + uint32_t firstSet + uint32_t descriptorSetCount + const VkDescriptorSet* pDescriptorSets + uint32_t dynamicOffsetCount + const uint32_t* pDynamicOffsets + + + void vkCmdBindIndexBuffer + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + VkIndexType indexType + + + void vkCmdBindVertexBuffers + VkCommandBuffer commandBuffer + uint32_t firstBinding + uint32_t bindingCount + const VkBuffer* pBuffers + const VkDeviceSize* pOffsets + + + void vkCmdDraw + VkCommandBuffer commandBuffer + uint32_t vertexCount + uint32_t instanceCount + uint32_t firstVertex + uint32_t firstInstance + + + void vkCmdDrawIndexed + VkCommandBuffer commandBuffer + uint32_t indexCount + uint32_t instanceCount + uint32_t firstIndex + int32_t vertexOffset + uint32_t firstInstance + + + void vkCmdDrawMultiEXT + VkCommandBuffer commandBuffer + uint32_t drawCount + const VkMultiDrawInfoEXT* pVertexInfo + uint32_t instanceCount + uint32_t firstInstance + uint32_t stride + + + void vkCmdDrawMultiIndexedEXT + VkCommandBuffer commandBuffer + uint32_t drawCount + const VkMultiDrawIndexedInfoEXT* pIndexInfo + uint32_t instanceCount + uint32_t firstInstance + uint32_t stride + const int32_t* pVertexOffset + + + void vkCmdDrawIndirect + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + uint32_t drawCount + uint32_t stride + + + void vkCmdDrawIndexedIndirect + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + uint32_t drawCount + uint32_t stride + + + void vkCmdDispatch + VkCommandBuffer commandBuffer + uint32_t groupCountX + uint32_t groupCountY + uint32_t groupCountZ + + + void vkCmdDispatchIndirect + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + + + void vkCmdSubpassShadingHUAWEI + VkCommandBuffer commandBuffer + + + void vkCmdCopyBuffer + VkCommandBuffer commandBuffer + VkBuffer srcBuffer + VkBuffer dstBuffer + uint32_t regionCount + const VkBufferCopy* pRegions + + + void vkCmdCopyImage + VkCommandBuffer commandBuffer + VkImage srcImage + VkImageLayout srcImageLayout + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkImageCopy* pRegions + + + void vkCmdBlitImage + VkCommandBuffer commandBuffer + VkImage srcImage + VkImageLayout srcImageLayout + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkImageBlit* pRegions + VkFilter filter + + + void vkCmdCopyBufferToImage + VkCommandBuffer commandBuffer + VkBuffer srcBuffer + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkBufferImageCopy* pRegions + + + void vkCmdCopyImageToBuffer + VkCommandBuffer commandBuffer + VkImage srcImage + VkImageLayout srcImageLayout + VkBuffer dstBuffer + uint32_t regionCount + const VkBufferImageCopy* pRegions + + + void vkCmdUpdateBuffer + VkCommandBuffer commandBuffer + VkBuffer dstBuffer + VkDeviceSize dstOffset + VkDeviceSize dataSize + const void* pData + + + void vkCmdFillBuffer + VkCommandBuffer commandBuffer + VkBuffer dstBuffer + VkDeviceSize dstOffset + VkDeviceSize size + uint32_t data + + + void vkCmdClearColorImage + VkCommandBuffer commandBuffer + VkImage image + VkImageLayout imageLayout + const VkClearColorValue* pColor + uint32_t rangeCount + const VkImageSubresourceRange* pRanges + + + void vkCmdClearDepthStencilImage + VkCommandBuffer commandBuffer + VkImage image + VkImageLayout imageLayout + const VkClearDepthStencilValue* pDepthStencil + uint32_t rangeCount + const VkImageSubresourceRange* pRanges + + + void vkCmdClearAttachments + VkCommandBuffer commandBuffer + uint32_t attachmentCount + const VkClearAttachment* pAttachments + uint32_t rectCount + const VkClearRect* pRects + + + void vkCmdResolveImage + VkCommandBuffer commandBuffer + VkImage srcImage + VkImageLayout srcImageLayout + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkImageResolve* pRegions + + + void vkCmdSetEvent + VkCommandBuffer commandBuffer + VkEvent event + VkPipelineStageFlags stageMask + + + void vkCmdResetEvent + VkCommandBuffer commandBuffer + VkEvent event + VkPipelineStageFlags stageMask + + + void vkCmdWaitEvents + VkCommandBuffer commandBuffer + uint32_t eventCount + const VkEvent* pEvents + VkPipelineStageFlags srcStageMask + VkPipelineStageFlags dstStageMask + uint32_t memoryBarrierCount + const VkMemoryBarrier* pMemoryBarriers + uint32_t bufferMemoryBarrierCount + const VkBufferMemoryBarrier* pBufferMemoryBarriers + uint32_t imageMemoryBarrierCount + const VkImageMemoryBarrier* pImageMemoryBarriers + + + void vkCmdPipelineBarrier + VkCommandBuffer commandBuffer + VkPipelineStageFlags srcStageMask + VkPipelineStageFlags dstStageMask + VkDependencyFlags dependencyFlags + uint32_t memoryBarrierCount + const VkMemoryBarrier* pMemoryBarriers + uint32_t bufferMemoryBarrierCount + const VkBufferMemoryBarrier* pBufferMemoryBarriers + uint32_t imageMemoryBarrierCount + const VkImageMemoryBarrier* pImageMemoryBarriers + + + void vkCmdBeginQuery + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t query + VkQueryControlFlags flags + + + void vkCmdEndQuery + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t query + + + void vkCmdBeginConditionalRenderingEXT + VkCommandBuffer commandBuffer + const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin + + + void vkCmdEndConditionalRenderingEXT + VkCommandBuffer commandBuffer + + + void vkCmdResetQueryPool + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t firstQuery + uint32_t queryCount + + + void vkCmdWriteTimestamp + VkCommandBuffer commandBuffer + VkPipelineStageFlagBits pipelineStage + VkQueryPool queryPool + uint32_t query + + + void vkCmdCopyQueryPoolResults + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t firstQuery + uint32_t queryCount + VkBuffer dstBuffer + VkDeviceSize dstOffset + VkDeviceSize stride + VkQueryResultFlags flags + + + void vkCmdPushConstants + VkCommandBuffer commandBuffer + VkPipelineLayout layout + VkShaderStageFlags stageFlags + uint32_t offset + uint32_t size + const void* pValues + + + void vkCmdBeginRenderPass + VkCommandBuffer commandBuffer + const VkRenderPassBeginInfo* pRenderPassBegin + VkSubpassContents contents + + + void vkCmdNextSubpass + VkCommandBuffer commandBuffer + VkSubpassContents contents + + + void vkCmdEndRenderPass + VkCommandBuffer commandBuffer + + + void vkCmdExecuteCommands + VkCommandBuffer commandBuffer + uint32_t commandBufferCount + const VkCommandBuffer* pCommandBuffers + + + VkResult vkCreateAndroidSurfaceKHR + VkInstance instance + const VkAndroidSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkGetPhysicalDeviceDisplayPropertiesKHR + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkDisplayPropertiesKHR* pProperties + + + VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkDisplayPlanePropertiesKHR* pProperties + + + VkResult vkGetDisplayPlaneSupportedDisplaysKHR + VkPhysicalDevice physicalDevice + uint32_t planeIndex + uint32_t* pDisplayCount + VkDisplayKHR* pDisplays + + + VkResult vkGetDisplayModePropertiesKHR + VkPhysicalDevice physicalDevice + VkDisplayKHR display + uint32_t* pPropertyCount + VkDisplayModePropertiesKHR* pProperties + + + VkResult vkCreateDisplayModeKHR + VkPhysicalDevice physicalDevice + VkDisplayKHR display + const VkDisplayModeCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDisplayModeKHR* pMode + + + VkResult vkGetDisplayPlaneCapabilitiesKHR + VkPhysicalDevice physicalDevice + VkDisplayModeKHR mode + uint32_t planeIndex + VkDisplayPlaneCapabilitiesKHR* pCapabilities + + + VkResult vkCreateDisplayPlaneSurfaceKHR + VkInstance instance + const VkDisplaySurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkCreateSharedSwapchainsKHR + VkDevice device + uint32_t swapchainCount + const VkSwapchainCreateInfoKHR* pCreateInfos + const VkSwapchainCreateInfoKHR* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkSwapchainKHR* pSwapchains + + + void vkDestroySurfaceKHR + VkInstance instance + VkSurfaceKHR surface + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetPhysicalDeviceSurfaceSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + VkSurfaceKHR surface + VkBool32* pSupported + + + VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities + + + VkResult vkGetPhysicalDeviceSurfaceFormatsKHR + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + uint32_t* pSurfaceFormatCount + VkSurfaceFormatKHR* pSurfaceFormats + + + VkResult vkGetPhysicalDeviceSurfacePresentModesKHR + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + uint32_t* pPresentModeCount + VkPresentModeKHR* pPresentModes + + + VkResult vkCreateSwapchainKHR + VkDevice device + const VkSwapchainCreateInfoKHR* pCreateInfo + const VkSwapchainCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSwapchainKHR* pSwapchain + + + void vkDestroySwapchainKHR + VkDevice device + VkSwapchainKHR swapchain + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetSwapchainImagesKHR + VkDevice device + VkSwapchainKHR swapchain + uint32_t* pSwapchainImageCount + VkImage* pSwapchainImages + + + VkResult vkAcquireNextImageKHR + VkDevice device + VkSwapchainKHR swapchain + uint64_t timeout + VkSemaphore semaphore + VkFence fence + uint32_t* pImageIndex + + + VkResult vkQueuePresentKHR + VkQueue queue + const VkPresentInfoKHR* pPresentInfo + + + VkResult vkCreateViSurfaceNN + VkInstance instance + const VkViSurfaceCreateInfoNN* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkCreateWaylandSurfaceKHR + VkInstance instance + const VkWaylandSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + struct wl_display* display + + + VkResult vkCreateWin32SurfaceKHR + VkInstance instance + const VkWin32SurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + + + VkResult vkCreateXlibSurfaceKHR + VkInstance instance + const VkXlibSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + Display* dpy + VisualID visualID + + + VkResult vkCreateXcbSurfaceKHR + VkInstance instance + const VkXcbSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + xcb_connection_t* connection + xcb_visualid_t visual_id + + + VkResult vkCreateDirectFBSurfaceEXT + VkInstance instance + const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceDirectFBPresentationSupportEXT + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + IDirectFB* dfb + + + VkResult vkCreateImagePipeSurfaceFUCHSIA + VkInstance instance + const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkCreateStreamDescriptorSurfaceGGP + VkInstance instance + const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkCreateScreenSurfaceQNX + VkInstance instance + const VkScreenSurfaceCreateInfoQNX* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + struct _screen_window* window + + + VkResult vkCreateDebugReportCallbackEXT + VkInstance instance + const VkDebugReportCallbackCreateInfoEXT* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDebugReportCallbackEXT* pCallback + + + void vkDestroyDebugReportCallbackEXT + VkInstance instance + VkDebugReportCallbackEXT callback + const VkAllocationCallbacks* pAllocator + + + void vkDebugReportMessageEXT + VkInstance instance + VkDebugReportFlagsEXT flags + VkDebugReportObjectTypeEXT objectType + uint64_t object + size_t location + int32_t messageCode + const char* pLayerPrefix + const char* pMessage + + + VkResult vkDebugMarkerSetObjectNameEXT + VkDevice device + const VkDebugMarkerObjectNameInfoEXT* pNameInfo + + + VkResult vkDebugMarkerSetObjectTagEXT + VkDevice device + const VkDebugMarkerObjectTagInfoEXT* pTagInfo + + + void vkCmdDebugMarkerBeginEXT + VkCommandBuffer commandBuffer + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo + + + void vkCmdDebugMarkerEndEXT + VkCommandBuffer commandBuffer + + + void vkCmdDebugMarkerInsertEXT + VkCommandBuffer commandBuffer + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo + + + VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV + VkPhysicalDevice physicalDevice + VkFormat format + VkImageType type + VkImageTiling tiling + VkImageUsageFlags usage + VkImageCreateFlags flags + VkExternalMemoryHandleTypeFlagsNV externalHandleType + VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties + + + VkResult vkGetMemoryWin32HandleNV + VkDevice device + VkDeviceMemory memory + VkExternalMemoryHandleTypeFlagsNV handleType + HANDLE* pHandle + + + void vkCmdExecuteGeneratedCommandsNV + VkCommandBuffer commandBuffer + VkBool32 isPreprocessed + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo + + + void vkCmdPreprocessGeneratedCommandsNV + VkCommandBuffer commandBuffer + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo + + + void vkCmdBindPipelineShaderGroupNV + VkCommandBuffer commandBuffer + VkPipelineBindPoint pipelineBindPoint + VkPipeline pipeline + uint32_t groupIndex + + + void vkGetGeneratedCommandsMemoryRequirementsNV + VkDevice device + const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo + VkMemoryRequirements2* pMemoryRequirements + + + VkResult vkCreateIndirectCommandsLayoutNV + VkDevice device + const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkIndirectCommandsLayoutNV* pIndirectCommandsLayout + + + void vkDestroyIndirectCommandsLayoutNV + VkDevice device + VkIndirectCommandsLayoutNV indirectCommandsLayout + const VkAllocationCallbacks* pAllocator + + + void vkGetPhysicalDeviceFeatures2 + VkPhysicalDevice physicalDevice + VkPhysicalDeviceFeatures2* pFeatures + + + + void vkGetPhysicalDeviceProperties2 + VkPhysicalDevice physicalDevice + VkPhysicalDeviceProperties2* pProperties + + + + void vkGetPhysicalDeviceFormatProperties2 + VkPhysicalDevice physicalDevice + VkFormat format + VkFormatProperties2* pFormatProperties + + + + VkResult vkGetPhysicalDeviceImageFormatProperties2 + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo + VkImageFormatProperties2* pImageFormatProperties + + + + void vkGetPhysicalDeviceQueueFamilyProperties2 + VkPhysicalDevice physicalDevice + uint32_t* pQueueFamilyPropertyCount + VkQueueFamilyProperties2* pQueueFamilyProperties + + + + void vkGetPhysicalDeviceMemoryProperties2 + VkPhysicalDevice physicalDevice + VkPhysicalDeviceMemoryProperties2* pMemoryProperties + + + + void vkGetPhysicalDeviceSparseImageFormatProperties2 + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo + uint32_t* pPropertyCount + VkSparseImageFormatProperties2* pProperties + + + + void vkCmdPushDescriptorSetKHR + VkCommandBuffer commandBuffer + VkPipelineBindPoint pipelineBindPoint + VkPipelineLayout layout + uint32_t set + uint32_t descriptorWriteCount + const VkWriteDescriptorSet* pDescriptorWrites + + + void vkTrimCommandPool + VkDevice device + VkCommandPool commandPool + VkCommandPoolTrimFlags flags + + + + void vkGetPhysicalDeviceExternalBufferProperties + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo + VkExternalBufferProperties* pExternalBufferProperties + + + + VkResult vkGetMemoryWin32HandleKHR + VkDevice device + const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo + HANDLE* pHandle + + + VkResult vkGetMemoryWin32HandlePropertiesKHR + VkDevice device + VkExternalMemoryHandleTypeFlagBits handleType + HANDLE handle + VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties + + + VkResult vkGetMemoryFdKHR + VkDevice device + const VkMemoryGetFdInfoKHR* pGetFdInfo + int* pFd + + + VkResult vkGetMemoryFdPropertiesKHR + VkDevice device + VkExternalMemoryHandleTypeFlagBits handleType + int fd + VkMemoryFdPropertiesKHR* pMemoryFdProperties + + + VkResult vkGetMemoryZirconHandleFUCHSIA + VkDevice device + const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo + zx_handle_t* pZirconHandle + + + VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA + VkDevice device + VkExternalMemoryHandleTypeFlagBits handleType + zx_handle_t zirconHandle + VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties + + + VkResult vkGetMemoryRemoteAddressNV + VkDevice device + const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo + VkRemoteAddressNV* pAddress + + + void vkGetPhysicalDeviceExternalSemaphoreProperties + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo + VkExternalSemaphoreProperties* pExternalSemaphoreProperties + + + + VkResult vkGetSemaphoreWin32HandleKHR + VkDevice device + const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo + HANDLE* pHandle + + + VkResult vkImportSemaphoreWin32HandleKHR + VkDevice device + const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo + + + VkResult vkGetSemaphoreFdKHR + VkDevice device + const VkSemaphoreGetFdInfoKHR* pGetFdInfo + int* pFd + + + VkResult vkImportSemaphoreFdKHR + VkDevice device + const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo + + + VkResult vkGetSemaphoreZirconHandleFUCHSIA + VkDevice device + const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo + zx_handle_t* pZirconHandle + + + VkResult vkImportSemaphoreZirconHandleFUCHSIA + VkDevice device + const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo + + + void vkGetPhysicalDeviceExternalFenceProperties + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo + VkExternalFenceProperties* pExternalFenceProperties + + + + VkResult vkGetFenceWin32HandleKHR + VkDevice device + const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo + HANDLE* pHandle + + + VkResult vkImportFenceWin32HandleKHR + VkDevice device + const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo + + + VkResult vkGetFenceFdKHR + VkDevice device + const VkFenceGetFdInfoKHR* pGetFdInfo + int* pFd + + + VkResult vkImportFenceFdKHR + VkDevice device + const VkImportFenceFdInfoKHR* pImportFenceFdInfo + + + VkResult vkReleaseDisplayEXT + VkPhysicalDevice physicalDevice + VkDisplayKHR display + + + VkResult vkAcquireXlibDisplayEXT + VkPhysicalDevice physicalDevice + Display* dpy + VkDisplayKHR display + + + VkResult vkGetRandROutputDisplayEXT + VkPhysicalDevice physicalDevice + Display* dpy + RROutput rrOutput + VkDisplayKHR* pDisplay + + + VkResult vkAcquireWinrtDisplayNV + VkPhysicalDevice physicalDevice + VkDisplayKHR display + + + VkResult vkGetWinrtDisplayNV + VkPhysicalDevice physicalDevice + uint32_t deviceRelativeId + VkDisplayKHR* pDisplay + + + VkResult vkDisplayPowerControlEXT + VkDevice device + VkDisplayKHR display + const VkDisplayPowerInfoEXT* pDisplayPowerInfo + + + VkResult vkRegisterDeviceEventEXT + VkDevice device + const VkDeviceEventInfoEXT* pDeviceEventInfo + const VkAllocationCallbacks* pAllocator + VkFence* pFence + + + VkResult vkRegisterDisplayEventEXT + VkDevice device + VkDisplayKHR display + const VkDisplayEventInfoEXT* pDisplayEventInfo + const VkAllocationCallbacks* pAllocator + VkFence* pFence + + + VkResult vkGetSwapchainCounterEXT + VkDevice device + VkSwapchainKHR swapchain + VkSurfaceCounterFlagBitsEXT counter + uint64_t* pCounterValue + + + VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + VkSurfaceCapabilities2EXT* pSurfaceCapabilities + + + VkResult vkEnumeratePhysicalDeviceGroups + VkInstance instance + uint32_t* pPhysicalDeviceGroupCount + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties + + + + void vkGetDeviceGroupPeerMemoryFeatures + VkDevice device + uint32_t heapIndex + uint32_t localDeviceIndex + uint32_t remoteDeviceIndex + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures + + + + VkResult vkBindBufferMemory2 + VkDevice device + uint32_t bindInfoCount + const VkBindBufferMemoryInfo* pBindInfos + + + + VkResult vkBindImageMemory2 + VkDevice device + uint32_t bindInfoCount + const VkBindImageMemoryInfo* pBindInfos + + + + void vkCmdSetDeviceMask + VkCommandBuffer commandBuffer + uint32_t deviceMask + + + + VkResult vkGetDeviceGroupPresentCapabilitiesKHR + VkDevice device + VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities + + + VkResult vkGetDeviceGroupSurfacePresentModesKHR + VkDevice device + VkSurfaceKHR surface + VkDeviceGroupPresentModeFlagsKHR* pModes + + + VkResult vkAcquireNextImage2KHR + VkDevice device + const VkAcquireNextImageInfoKHR* pAcquireInfo + uint32_t* pImageIndex + + + void vkCmdDispatchBase + VkCommandBuffer commandBuffer + uint32_t baseGroupX + uint32_t baseGroupY + uint32_t baseGroupZ + uint32_t groupCountX + uint32_t groupCountY + uint32_t groupCountZ + + + + VkResult vkGetPhysicalDevicePresentRectanglesKHR + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + uint32_t* pRectCount + VkRect2D* pRects + + + VkResult vkCreateDescriptorUpdateTemplate + VkDevice device + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate + + + + void vkDestroyDescriptorUpdateTemplate + VkDevice device + VkDescriptorUpdateTemplate descriptorUpdateTemplate + const VkAllocationCallbacks* pAllocator + + + + void vkUpdateDescriptorSetWithTemplate + VkDevice device + VkDescriptorSet descriptorSet + VkDescriptorUpdateTemplate descriptorUpdateTemplate + const void* pData + + + + void vkCmdPushDescriptorSetWithTemplateKHR + VkCommandBuffer commandBuffer + VkDescriptorUpdateTemplate descriptorUpdateTemplate + VkPipelineLayout layout + uint32_t set + const void* pData + + + void vkSetHdrMetadataEXT + VkDevice device + uint32_t swapchainCount + const VkSwapchainKHR* pSwapchains + const VkHdrMetadataEXT* pMetadata + + + VkResult vkGetSwapchainStatusKHR + VkDevice device + VkSwapchainKHR swapchain + + + VkResult vkGetRefreshCycleDurationGOOGLE + VkDevice device + VkSwapchainKHR swapchain + VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties + + + VkResult vkGetPastPresentationTimingGOOGLE + VkDevice device + VkSwapchainKHR swapchain + uint32_t* pPresentationTimingCount + VkPastPresentationTimingGOOGLE* pPresentationTimings + + + VkResult vkCreateIOSSurfaceMVK + VkInstance instance + const VkIOSSurfaceCreateInfoMVK* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkCreateMacOSSurfaceMVK + VkInstance instance + const VkMacOSSurfaceCreateInfoMVK* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkCreateMetalSurfaceEXT + VkInstance instance + const VkMetalSurfaceCreateInfoEXT* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + void vkCmdSetViewportWScalingNV + VkCommandBuffer commandBuffer + uint32_t firstViewport + uint32_t viewportCount + const VkViewportWScalingNV* pViewportWScalings + + + void vkCmdSetDiscardRectangleEXT + VkCommandBuffer commandBuffer + uint32_t firstDiscardRectangle + uint32_t discardRectangleCount + const VkRect2D* pDiscardRectangles + + + void vkCmdSetSampleLocationsEXT + VkCommandBuffer commandBuffer + const VkSampleLocationsInfoEXT* pSampleLocationsInfo + + + void vkGetPhysicalDeviceMultisamplePropertiesEXT + VkPhysicalDevice physicalDevice + VkSampleCountFlagBits samples + VkMultisamplePropertiesEXT* pMultisampleProperties + + + VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo + VkSurfaceCapabilities2KHR* pSurfaceCapabilities + + + VkResult vkGetPhysicalDeviceSurfaceFormats2KHR + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo + uint32_t* pSurfaceFormatCount + VkSurfaceFormat2KHR* pSurfaceFormats + + + VkResult vkGetPhysicalDeviceDisplayProperties2KHR + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkDisplayProperties2KHR* pProperties + + + VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkDisplayPlaneProperties2KHR* pProperties + + + VkResult vkGetDisplayModeProperties2KHR + VkPhysicalDevice physicalDevice + VkDisplayKHR display + uint32_t* pPropertyCount + VkDisplayModeProperties2KHR* pProperties + + + VkResult vkGetDisplayPlaneCapabilities2KHR + VkPhysicalDevice physicalDevice + const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo + VkDisplayPlaneCapabilities2KHR* pCapabilities + + + void vkGetBufferMemoryRequirements2 + VkDevice device + const VkBufferMemoryRequirementsInfo2* pInfo + VkMemoryRequirements2* pMemoryRequirements + + + + void vkGetImageMemoryRequirements2 + VkDevice device + const VkImageMemoryRequirementsInfo2* pInfo + VkMemoryRequirements2* pMemoryRequirements + + + + void vkGetImageSparseMemoryRequirements2 + VkDevice device + const VkImageSparseMemoryRequirementsInfo2* pInfo + uint32_t* pSparseMemoryRequirementCount + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements + + + void vkGetDeviceBufferMemoryRequirementsKHR + VkDevice device + const VkDeviceBufferMemoryRequirementsKHR* pInfo + VkMemoryRequirements2* pMemoryRequirements + + + void vkGetDeviceImageMemoryRequirementsKHR + VkDevice device + const VkDeviceImageMemoryRequirementsKHR* pInfo + VkMemoryRequirements2* pMemoryRequirements + + + void vkGetDeviceImageSparseMemoryRequirementsKHR + VkDevice device + const VkDeviceImageMemoryRequirementsKHR* pInfo + uint32_t* pSparseMemoryRequirementCount + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements + + + + VkResult vkCreateSamplerYcbcrConversion + VkDevice device + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSamplerYcbcrConversion* pYcbcrConversion + + + + void vkDestroySamplerYcbcrConversion + VkDevice device + VkSamplerYcbcrConversion ycbcrConversion + const VkAllocationCallbacks* pAllocator + + + + void vkGetDeviceQueue2 + VkDevice device + const VkDeviceQueueInfo2* pQueueInfo + VkQueue* pQueue + + + VkResult vkCreateValidationCacheEXT + VkDevice device + const VkValidationCacheCreateInfoEXT* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkValidationCacheEXT* pValidationCache + + + void vkDestroyValidationCacheEXT + VkDevice device + VkValidationCacheEXT validationCache + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetValidationCacheDataEXT + VkDevice device + VkValidationCacheEXT validationCache + size_t* pDataSize + void* pData + + + VkResult vkMergeValidationCachesEXT + VkDevice device + VkValidationCacheEXT dstCache + uint32_t srcCacheCount + const VkValidationCacheEXT* pSrcCaches + + + void vkGetDescriptorSetLayoutSupport + VkDevice device + const VkDescriptorSetLayoutCreateInfo* pCreateInfo + VkDescriptorSetLayoutSupport* pSupport + + + + VkResult vkGetSwapchainGrallocUsageANDROID + VkDevice device + VkFormat format + VkImageUsageFlags imageUsage + int* grallocUsage + + + VkResult vkGetSwapchainGrallocUsage2ANDROID + VkDevice device + VkFormat format + VkImageUsageFlags imageUsage + VkSwapchainImageUsageFlagsANDROID swapchainImageUsage + uint64_t* grallocConsumerUsage + uint64_t* grallocProducerUsage + + + VkResult vkAcquireImageANDROID + VkDevice device + VkImage image + int nativeFenceFd + VkSemaphore semaphore + VkFence fence + + + VkResult vkQueueSignalReleaseImageANDROID + VkQueue queue + uint32_t waitSemaphoreCount + const VkSemaphore* pWaitSemaphores + VkImage image + int* pNativeFenceFd + + + VkResult vkGetShaderInfoAMD + VkDevice device + VkPipeline pipeline + VkShaderStageFlagBits shaderStage + VkShaderInfoTypeAMD infoType + size_t* pInfoSize + void* pInfo + + + void vkSetLocalDimmingAMD + VkDevice device + VkSwapchainKHR swapChain + VkBool32 localDimmingEnable + + + VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT + VkPhysicalDevice physicalDevice + uint32_t* pTimeDomainCount + VkTimeDomainEXT* pTimeDomains + + + VkResult vkGetCalibratedTimestampsEXT + VkDevice device + uint32_t timestampCount + const VkCalibratedTimestampInfoEXT* pTimestampInfos + uint64_t* pTimestamps + uint64_t* pMaxDeviation + + + VkResult vkSetDebugUtilsObjectNameEXT + VkDevice device + const VkDebugUtilsObjectNameInfoEXT* pNameInfo + + + VkResult vkSetDebugUtilsObjectTagEXT + VkDevice device + const VkDebugUtilsObjectTagInfoEXT* pTagInfo + + + void vkQueueBeginDebugUtilsLabelEXT + VkQueue queue + const VkDebugUtilsLabelEXT* pLabelInfo + + + void vkQueueEndDebugUtilsLabelEXT + VkQueue queue + + + void vkQueueInsertDebugUtilsLabelEXT + VkQueue queue + const VkDebugUtilsLabelEXT* pLabelInfo + + + void vkCmdBeginDebugUtilsLabelEXT + VkCommandBuffer commandBuffer + const VkDebugUtilsLabelEXT* pLabelInfo + + + void vkCmdEndDebugUtilsLabelEXT + VkCommandBuffer commandBuffer + + + void vkCmdInsertDebugUtilsLabelEXT + VkCommandBuffer commandBuffer + const VkDebugUtilsLabelEXT* pLabelInfo + + + VkResult vkCreateDebugUtilsMessengerEXT + VkInstance instance + const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDebugUtilsMessengerEXT* pMessenger + + + void vkDestroyDebugUtilsMessengerEXT + VkInstance instance + VkDebugUtilsMessengerEXT messenger + const VkAllocationCallbacks* pAllocator + + + void vkSubmitDebugUtilsMessageEXT + VkInstance instance + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity + VkDebugUtilsMessageTypeFlagsEXT messageTypes + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData + + + VkResult vkGetMemoryHostPointerPropertiesEXT + VkDevice device + VkExternalMemoryHandleTypeFlagBits handleType + const void* pHostPointer + VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties + + + void vkCmdWriteBufferMarkerAMD + VkCommandBuffer commandBuffer + VkPipelineStageFlagBits pipelineStage + VkBuffer dstBuffer + VkDeviceSize dstOffset + uint32_t marker + + + VkResult vkCreateRenderPass2 + VkDevice device + const VkRenderPassCreateInfo2* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkRenderPass* pRenderPass + + + + void vkCmdBeginRenderPass2 + VkCommandBuffer commandBuffer + const VkRenderPassBeginInfo* pRenderPassBegin + const VkSubpassBeginInfo* pSubpassBeginInfo + + + + void vkCmdNextSubpass2 + VkCommandBuffer commandBuffer + const VkSubpassBeginInfo* pSubpassBeginInfo + const VkSubpassEndInfo* pSubpassEndInfo + + + + void vkCmdEndRenderPass2 + VkCommandBuffer commandBuffer + const VkSubpassEndInfo* pSubpassEndInfo + + + + VkResult vkGetSemaphoreCounterValue + VkDevice device + VkSemaphore semaphore + uint64_t* pValue + + + + VkResult vkWaitSemaphores + VkDevice device + const VkSemaphoreWaitInfo* pWaitInfo + uint64_t timeout + + + + VkResult vkSignalSemaphore + VkDevice device + const VkSemaphoreSignalInfo* pSignalInfo + + + + VkResult vkGetAndroidHardwareBufferPropertiesANDROID + VkDevice device + const struct AHardwareBuffer* buffer + VkAndroidHardwareBufferPropertiesANDROID* pProperties + + + VkResult vkGetMemoryAndroidHardwareBufferANDROID + VkDevice device + const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo + struct AHardwareBuffer** pBuffer + + + void vkCmdDrawIndirectCount + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + VkBuffer countBuffer + VkDeviceSize countBufferOffset + uint32_t maxDrawCount + uint32_t stride + + + + + void vkCmdDrawIndexedIndirectCount + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + VkBuffer countBuffer + VkDeviceSize countBufferOffset + uint32_t maxDrawCount + uint32_t stride + + + + + void vkCmdSetCheckpointNV + VkCommandBuffer commandBuffer + const void* pCheckpointMarker + + + void vkGetQueueCheckpointDataNV + VkQueue queue + uint32_t* pCheckpointDataCount + VkCheckpointDataNV* pCheckpointData + + + void vkCmdBindTransformFeedbackBuffersEXT + VkCommandBuffer commandBuffer + uint32_t firstBinding + uint32_t bindingCount + const VkBuffer* pBuffers + const VkDeviceSize* pOffsets + const VkDeviceSize* pSizes + + + void vkCmdBeginTransformFeedbackEXT + VkCommandBuffer commandBuffer + uint32_t firstCounterBuffer + uint32_t counterBufferCount + const VkBuffer* pCounterBuffers + const VkDeviceSize* pCounterBufferOffsets + + + void vkCmdEndTransformFeedbackEXT + VkCommandBuffer commandBuffer + uint32_t firstCounterBuffer + uint32_t counterBufferCount + const VkBuffer* pCounterBuffers + const VkDeviceSize* pCounterBufferOffsets + + + void vkCmdBeginQueryIndexedEXT + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t query + VkQueryControlFlags flags + uint32_t index + + + void vkCmdEndQueryIndexedEXT + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t query + uint32_t index + + + void vkCmdDrawIndirectByteCountEXT + VkCommandBuffer commandBuffer + uint32_t instanceCount + uint32_t firstInstance + VkBuffer counterBuffer + VkDeviceSize counterBufferOffset + uint32_t counterOffset + uint32_t vertexStride + + + void vkCmdSetExclusiveScissorNV + VkCommandBuffer commandBuffer + uint32_t firstExclusiveScissor + uint32_t exclusiveScissorCount + const VkRect2D* pExclusiveScissors + + + void vkCmdBindShadingRateImageNV + VkCommandBuffer commandBuffer + VkImageView imageView + VkImageLayout imageLayout + + + void vkCmdSetViewportShadingRatePaletteNV + VkCommandBuffer commandBuffer + uint32_t firstViewport + uint32_t viewportCount + const VkShadingRatePaletteNV* pShadingRatePalettes + + + void vkCmdSetCoarseSampleOrderNV + VkCommandBuffer commandBuffer + VkCoarseSampleOrderTypeNV sampleOrderType + uint32_t customSampleOrderCount + const VkCoarseSampleOrderCustomNV* pCustomSampleOrders + + + void vkCmdDrawMeshTasksNV + VkCommandBuffer commandBuffer + uint32_t taskCount + uint32_t firstTask + + + void vkCmdDrawMeshTasksIndirectNV + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + uint32_t drawCount + uint32_t stride + + + void vkCmdDrawMeshTasksIndirectCountNV + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + VkBuffer countBuffer + VkDeviceSize countBufferOffset + uint32_t maxDrawCount + uint32_t stride + + + VkResult vkCompileDeferredNV + VkDevice device + VkPipeline pipeline + uint32_t shader + + + VkResult vkCreateAccelerationStructureNV + VkDevice device + const VkAccelerationStructureCreateInfoNV* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkAccelerationStructureNV* pAccelerationStructure + + + void vkCmdBindInvocationMaskHUAWEI + VkCommandBuffer commandBuffer + VkImageView imageView + VkImageLayout imageLayout + + + void vkDestroyAccelerationStructureKHR + VkDevice device + VkAccelerationStructureKHR accelerationStructure + const VkAllocationCallbacks* pAllocator + + + void vkDestroyAccelerationStructureNV + VkDevice device + VkAccelerationStructureNV accelerationStructure + const VkAllocationCallbacks* pAllocator + + + void vkGetAccelerationStructureMemoryRequirementsNV + VkDevice device + const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo + VkMemoryRequirements2KHR* pMemoryRequirements + + + VkResult vkBindAccelerationStructureMemoryNV + VkDevice device + uint32_t bindInfoCount + const VkBindAccelerationStructureMemoryInfoNV* pBindInfos + + + void vkCmdCopyAccelerationStructureNV + VkCommandBuffer commandBuffer + VkAccelerationStructureNV dst + VkAccelerationStructureNV src + VkCopyAccelerationStructureModeKHR mode + + + void vkCmdCopyAccelerationStructureKHR + VkCommandBuffer commandBuffer + const VkCopyAccelerationStructureInfoKHR* pInfo + + + VkResult vkCopyAccelerationStructureKHR + VkDevice device + VkDeferredOperationKHR deferredOperation + const VkCopyAccelerationStructureInfoKHR* pInfo + + + void vkCmdCopyAccelerationStructureToMemoryKHR + VkCommandBuffer commandBuffer + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo + + + VkResult vkCopyAccelerationStructureToMemoryKHR + VkDevice device + VkDeferredOperationKHR deferredOperation + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo + + + void vkCmdCopyMemoryToAccelerationStructureKHR + VkCommandBuffer commandBuffer + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo + + + VkResult vkCopyMemoryToAccelerationStructureKHR + VkDevice device + VkDeferredOperationKHR deferredOperation + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo + + + void vkCmdWriteAccelerationStructuresPropertiesKHR + VkCommandBuffer commandBuffer + uint32_t accelerationStructureCount + const VkAccelerationStructureKHR* pAccelerationStructures + VkQueryType queryType + VkQueryPool queryPool + uint32_t firstQuery + + + void vkCmdWriteAccelerationStructuresPropertiesNV + VkCommandBuffer commandBuffer + uint32_t accelerationStructureCount + const VkAccelerationStructureNV* pAccelerationStructures + VkQueryType queryType + VkQueryPool queryPool + uint32_t firstQuery + + + void vkCmdBuildAccelerationStructureNV + VkCommandBuffer commandBuffer + const VkAccelerationStructureInfoNV* pInfo + VkBuffer instanceData + VkDeviceSize instanceOffset + VkBool32 update + VkAccelerationStructureNV dst + VkAccelerationStructureNV src + VkBuffer scratch + VkDeviceSize scratchOffset + + + VkResult vkWriteAccelerationStructuresPropertiesKHR + VkDevice device + uint32_t accelerationStructureCount + const VkAccelerationStructureKHR* pAccelerationStructures + VkQueryType queryType + size_t dataSize + void* pData + size_t stride + + + void vkCmdTraceRaysKHR + VkCommandBuffer commandBuffer + const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable + const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable + const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable + const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable + uint32_t width + uint32_t height + uint32_t depth + + + void vkCmdTraceRaysNV + VkCommandBuffer commandBuffer + VkBuffer raygenShaderBindingTableBuffer + VkDeviceSize raygenShaderBindingOffset + VkBuffer missShaderBindingTableBuffer + VkDeviceSize missShaderBindingOffset + VkDeviceSize missShaderBindingStride + VkBuffer hitShaderBindingTableBuffer + VkDeviceSize hitShaderBindingOffset + VkDeviceSize hitShaderBindingStride + VkBuffer callableShaderBindingTableBuffer + VkDeviceSize callableShaderBindingOffset + VkDeviceSize callableShaderBindingStride + uint32_t width + uint32_t height + uint32_t depth + + + VkResult vkGetRayTracingShaderGroupHandlesKHR + VkDevice device + VkPipeline pipeline + uint32_t firstGroup + uint32_t groupCount + size_t dataSize + void* pData + + + + VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR + VkDevice device + VkPipeline pipeline + uint32_t firstGroup + uint32_t groupCount + size_t dataSize + void* pData + + + VkResult vkGetAccelerationStructureHandleNV + VkDevice device + VkAccelerationStructureNV accelerationStructure + size_t dataSize + void* pData + + + VkResult vkCreateRayTracingPipelinesNV + VkDevice device + VkPipelineCache pipelineCache + uint32_t createInfoCount + const VkRayTracingPipelineCreateInfoNV* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkPipeline* pPipelines + + + VkResult vkCreateRayTracingPipelinesKHR + VkDevice device + VkDeferredOperationKHR deferredOperation + VkPipelineCache pipelineCache + uint32_t createInfoCount + const VkRayTracingPipelineCreateInfoKHR* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkPipeline* pPipelines + + + VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkCooperativeMatrixPropertiesNV* pProperties + + + void vkCmdTraceRaysIndirectKHR + VkCommandBuffer commandBuffer + const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable + const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable + const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable + const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable + VkDeviceAddress indirectDeviceAddress + + + void vkGetDeviceAccelerationStructureCompatibilityKHR + VkDevice device + const VkAccelerationStructureVersionInfoKHR* pVersionInfo + VkAccelerationStructureCompatibilityKHR* pCompatibility + + + VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR + VkDevice device + VkPipeline pipeline + uint32_t group + VkShaderGroupShaderKHR groupShader + + + void vkCmdSetRayTracingPipelineStackSizeKHR + VkCommandBuffer commandBuffer + uint32_t pipelineStackSize + + + uint32_t vkGetImageViewHandleNVX + VkDevice device + const VkImageViewHandleInfoNVX* pInfo + + + VkResult vkGetImageViewAddressNVX + VkDevice device + VkImageView imageView + VkImageViewAddressPropertiesNVX* pProperties + + + VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo + uint32_t* pPresentModeCount + VkPresentModeKHR* pPresentModes + + + VkResult vkGetDeviceGroupSurfacePresentModes2EXT + VkDevice device + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo + VkDeviceGroupPresentModeFlagsKHR* pModes + + + VkResult vkAcquireFullScreenExclusiveModeEXT + VkDevice device + VkSwapchainKHR swapchain + + + VkResult vkReleaseFullScreenExclusiveModeEXT + VkDevice device + VkSwapchainKHR swapchain + + + VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + uint32_t* pCounterCount + VkPerformanceCounterKHR* pCounters + VkPerformanceCounterDescriptionKHR* pCounterDescriptions + + + void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR + VkPhysicalDevice physicalDevice + const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo + uint32_t* pNumPasses + + + VkResult vkAcquireProfilingLockKHR + VkDevice device + const VkAcquireProfilingLockInfoKHR* pInfo + + + void vkReleaseProfilingLockKHR + VkDevice device + + + VkResult vkGetImageDrmFormatModifierPropertiesEXT + VkDevice device + VkImage image + VkImageDrmFormatModifierPropertiesEXT* pProperties + + + uint64_t vkGetBufferOpaqueCaptureAddress + VkDevice device + const VkBufferDeviceAddressInfo* pInfo + + + + VkDeviceAddress vkGetBufferDeviceAddress + VkDevice device + const VkBufferDeviceAddressInfo* pInfo + + + + + VkResult vkCreateHeadlessSurfaceEXT + VkInstance instance + const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV + VkPhysicalDevice physicalDevice + uint32_t* pCombinationCount + VkFramebufferMixedSamplesCombinationNV* pCombinations + + + VkResult vkInitializePerformanceApiINTEL + VkDevice device + const VkInitializePerformanceApiInfoINTEL* pInitializeInfo + + + void vkUninitializePerformanceApiINTEL + VkDevice device + + + VkResult vkCmdSetPerformanceMarkerINTEL + VkCommandBuffer commandBuffer + const VkPerformanceMarkerInfoINTEL* pMarkerInfo + + + VkResult vkCmdSetPerformanceStreamMarkerINTEL + VkCommandBuffer commandBuffer + const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo + + + VkResult vkCmdSetPerformanceOverrideINTEL + VkCommandBuffer commandBuffer + const VkPerformanceOverrideInfoINTEL* pOverrideInfo + + + VkResult vkAcquirePerformanceConfigurationINTEL + VkDevice device + const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo + VkPerformanceConfigurationINTEL* pConfiguration + + + VkResult vkReleasePerformanceConfigurationINTEL + VkDevice device + VkPerformanceConfigurationINTEL configuration + + + VkResult vkQueueSetPerformanceConfigurationINTEL + VkQueue queue + VkPerformanceConfigurationINTEL configuration + + + VkResult vkGetPerformanceParameterINTEL + VkDevice device + VkPerformanceParameterTypeINTEL parameter + VkPerformanceValueINTEL* pValue + + + uint64_t vkGetDeviceMemoryOpaqueCaptureAddress + VkDevice device + const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo + + + + VkResult vkGetPipelineExecutablePropertiesKHR + VkDevice device + const VkPipelineInfoKHR* pPipelineInfo + uint32_t* pExecutableCount + VkPipelineExecutablePropertiesKHR* pProperties + + + VkResult vkGetPipelineExecutableStatisticsKHR + VkDevice device + const VkPipelineExecutableInfoKHR* pExecutableInfo + uint32_t* pStatisticCount + VkPipelineExecutableStatisticKHR* pStatistics + + + VkResult vkGetPipelineExecutableInternalRepresentationsKHR + VkDevice device + const VkPipelineExecutableInfoKHR* pExecutableInfo + uint32_t* pInternalRepresentationCount + VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations + + + void vkCmdSetLineStippleEXT + VkCommandBuffer commandBuffer + uint32_t lineStippleFactor + uint16_t lineStipplePattern + + + VkResult vkGetFaultData + VkDevice device + VkFaultQueryBehavior faultQueryBehavior + VkBool32* pUnrecordedFaults + uint32_t* pFaultCount + VkFaultData* pFaults + + + VkResult vkGetPhysicalDeviceToolPropertiesEXT + VkPhysicalDevice physicalDevice + uint32_t* pToolCount + VkPhysicalDeviceToolPropertiesEXT* pToolProperties + + + VkResult vkCreateAccelerationStructureKHR + VkDevice device + const VkAccelerationStructureCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkAccelerationStructureKHR* pAccelerationStructure + + + void vkCmdBuildAccelerationStructuresKHR + VkCommandBuffer commandBuffer + uint32_t infoCount + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos + + + void vkCmdBuildAccelerationStructuresIndirectKHR + VkCommandBuffer commandBuffer + uint32_t infoCount + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos + const VkDeviceAddress* pIndirectDeviceAddresses + const uint32_t* pIndirectStrides + const uint32_t* const* ppMaxPrimitiveCounts + + + VkResult vkBuildAccelerationStructuresKHR + VkDevice device + VkDeferredOperationKHR deferredOperation + uint32_t infoCount + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos + + + VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR + VkDevice device + const VkAccelerationStructureDeviceAddressInfoKHR* pInfo + + + VkResult vkCreateDeferredOperationKHR + VkDevice device + const VkAllocationCallbacks* pAllocator + VkDeferredOperationKHR* pDeferredOperation + + + void vkDestroyDeferredOperationKHR + VkDevice device + VkDeferredOperationKHR operation + const VkAllocationCallbacks* pAllocator + + + uint32_t vkGetDeferredOperationMaxConcurrencyKHR + VkDevice device + VkDeferredOperationKHR operation + + + VkResult vkGetDeferredOperationResultKHR + VkDevice device + VkDeferredOperationKHR operation + + + VkResult vkDeferredOperationJoinKHR + VkDevice device + VkDeferredOperationKHR operation + + + void vkCmdSetCullModeEXT + VkCommandBuffer commandBuffer + VkCullModeFlags cullMode + + + void vkCmdSetFrontFaceEXT + VkCommandBuffer commandBuffer + VkFrontFace frontFace + + + void vkCmdSetPrimitiveTopologyEXT + VkCommandBuffer commandBuffer + VkPrimitiveTopology primitiveTopology + + + void vkCmdSetViewportWithCountEXT + VkCommandBuffer commandBuffer + uint32_t viewportCount + const VkViewport* pViewports + + + void vkCmdSetScissorWithCountEXT + VkCommandBuffer commandBuffer + uint32_t scissorCount + const VkRect2D* pScissors + + + void vkCmdBindVertexBuffers2EXT + VkCommandBuffer commandBuffer + uint32_t firstBinding + uint32_t bindingCount + const VkBuffer* pBuffers + const VkDeviceSize* pOffsets + const VkDeviceSize* pSizes + const VkDeviceSize* pStrides + + + void vkCmdSetDepthTestEnableEXT + VkCommandBuffer commandBuffer + VkBool32 depthTestEnable + + + void vkCmdSetDepthWriteEnableEXT + VkCommandBuffer commandBuffer + VkBool32 depthWriteEnable + + + void vkCmdSetDepthCompareOpEXT + VkCommandBuffer commandBuffer + VkCompareOp depthCompareOp + + + void vkCmdSetDepthBoundsTestEnableEXT + VkCommandBuffer commandBuffer + VkBool32 depthBoundsTestEnable + + + void vkCmdSetStencilTestEnableEXT + VkCommandBuffer commandBuffer + VkBool32 stencilTestEnable + + + void vkCmdSetStencilOpEXT + VkCommandBuffer commandBuffer + VkStencilFaceFlags faceMask + VkStencilOp failOp + VkStencilOp passOp + VkStencilOp depthFailOp + VkCompareOp compareOp + + + void vkCmdSetPatchControlPointsEXT + VkCommandBuffer commandBuffer + uint32_t patchControlPoints + + + void vkCmdSetRasterizerDiscardEnableEXT + VkCommandBuffer commandBuffer + VkBool32 rasterizerDiscardEnable + + + void vkCmdSetDepthBiasEnableEXT + VkCommandBuffer commandBuffer + VkBool32 depthBiasEnable + + + void vkCmdSetLogicOpEXT + VkCommandBuffer commandBuffer + VkLogicOp logicOp + + + void vkCmdSetPrimitiveRestartEnableEXT + VkCommandBuffer commandBuffer + VkBool32 primitiveRestartEnable + + + VkResult vkCreatePrivateDataSlotEXT + VkDevice device + const VkPrivateDataSlotCreateInfoEXT* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkPrivateDataSlotEXT* pPrivateDataSlot + + + void vkDestroyPrivateDataSlotEXT + VkDevice device + VkPrivateDataSlotEXT privateDataSlot + const VkAllocationCallbacks* pAllocator + + + VkResult vkSetPrivateDataEXT + VkDevice device + VkObjectType objectType + uint64_t objectHandle + VkPrivateDataSlotEXT privateDataSlot + uint64_t data + + + void vkGetPrivateDataEXT + VkDevice device + VkObjectType objectType + uint64_t objectHandle + VkPrivateDataSlotEXT privateDataSlot + uint64_t* pData + + + void vkCmdCopyBuffer2KHR + VkCommandBuffer commandBuffer + const VkCopyBufferInfo2KHR* pCopyBufferInfo + + + void vkCmdCopyImage2KHR + VkCommandBuffer commandBuffer + const VkCopyImageInfo2KHR* pCopyImageInfo + + + void vkCmdBlitImage2KHR + VkCommandBuffer commandBuffer + const VkBlitImageInfo2KHR* pBlitImageInfo + + + void vkCmdCopyBufferToImage2KHR + VkCommandBuffer commandBuffer + const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo + + + void vkCmdCopyImageToBuffer2KHR + VkCommandBuffer commandBuffer + const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo + + + void vkCmdResolveImage2KHR + VkCommandBuffer commandBuffer + const VkResolveImageInfo2KHR* pResolveImageInfo + + + void vkCmdRefreshObjectsKHR + VkCommandBuffer commandBuffer + const VkRefreshObjectListKHR* pRefreshObjects + + + VkResult vkGetPhysicalDeviceRefreshableObjectTypesKHR + VkPhysicalDevice physicalDevice + uint32_t* pRefreshableObjectTypeCount + VkObjectType* pRefreshableObjectTypes + + + void vkCmdSetFragmentShadingRateKHR + VkCommandBuffer commandBuffer + const VkExtent2D* pFragmentSize + const VkFragmentShadingRateCombinerOpKHR combinerOps[2] + + + VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR + VkPhysicalDevice physicalDevice + uint32_t* pFragmentShadingRateCount + VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates + + + void vkCmdSetFragmentShadingRateEnumNV + VkCommandBuffer commandBuffer + VkFragmentShadingRateNV shadingRate + const VkFragmentShadingRateCombinerOpKHR combinerOps[2] + + + void vkGetAccelerationStructureBuildSizesKHR + VkDevice device + VkAccelerationStructureBuildTypeKHR buildType + const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo + const uint32_t* pMaxPrimitiveCounts + VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo + + + void vkCmdSetVertexInputEXT + VkCommandBuffer commandBuffer + uint32_t vertexBindingDescriptionCount + const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions + uint32_t vertexAttributeDescriptionCount + const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions + + + void vkCmdSetColorWriteEnableEXT + VkCommandBuffer commandBuffer + uint32_t attachmentCount + const VkBool32* pColorWriteEnables + + + void vkCmdSetEvent2KHR + VkCommandBuffer commandBuffer + VkEvent event + const VkDependencyInfoKHR* pDependencyInfo + + + void vkCmdResetEvent2KHR + VkCommandBuffer commandBuffer + VkEvent event + VkPipelineStageFlags2KHR stageMask + + + void vkCmdWaitEvents2KHR + VkCommandBuffer commandBuffer + uint32_t eventCount + const VkEvent* pEvents + const VkDependencyInfoKHR* pDependencyInfos + + + void vkCmdPipelineBarrier2KHR + VkCommandBuffer commandBuffer + const VkDependencyInfoKHR* pDependencyInfo + + + VkResult vkQueueSubmit2KHR + VkQueue queue + uint32_t submitCount + const VkSubmitInfo2KHR* pSubmits + VkFence fence + + + void vkCmdWriteTimestamp2KHR + VkCommandBuffer commandBuffer + VkPipelineStageFlags2KHR stage + VkQueryPool queryPool + uint32_t query + + + void vkCmdWriteBufferMarker2AMD + VkCommandBuffer commandBuffer + VkPipelineStageFlags2KHR stage + VkBuffer dstBuffer + VkDeviceSize dstOffset + uint32_t marker + + + void vkGetQueueCheckpointData2NV + VkQueue queue + uint32_t* pCheckpointDataCount + VkCheckpointData2NV* pCheckpointData + + + void vkGetCommandPoolMemoryConsumption + VkDevice device + VkCommandPool commandPool + VkCommandBuffer commandBuffer + VkCommandPoolMemoryConsumption* pConsumption + + + VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR + VkPhysicalDevice physicalDevice + const VkVideoProfileKHR* pVideoProfile + VkVideoCapabilitiesKHR* pCapabilities + + + VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo + uint32_t* pVideoFormatPropertyCount + VkVideoFormatPropertiesKHR* pVideoFormatProperties + + + VkResult vkCreateVideoSessionKHR + VkDevice device + const VkVideoSessionCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkVideoSessionKHR* pVideoSession + + + void vkDestroyVideoSessionKHR + VkDevice device + VkVideoSessionKHR videoSession + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateVideoSessionParametersKHR + VkDevice device + const VkVideoSessionParametersCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkVideoSessionParametersKHR* pVideoSessionParameters + + + VkResult vkUpdateVideoSessionParametersKHR + VkDevice device + VkVideoSessionParametersKHR videoSessionParameters + const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo + + + void vkDestroyVideoSessionParametersKHR + VkDevice device + VkVideoSessionParametersKHR videoSessionParameters + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetVideoSessionMemoryRequirementsKHR + VkDevice device + VkVideoSessionKHR videoSession + uint32_t* pVideoSessionMemoryRequirementsCount + VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements + + + VkResult vkBindVideoSessionMemoryKHR + VkDevice device + VkVideoSessionKHR videoSession + uint32_t videoSessionBindMemoryCount + const VkVideoBindMemoryKHR* pVideoSessionBindMemories + + + void vkCmdDecodeVideoKHR + VkCommandBuffer commandBuffer + const VkVideoDecodeInfoKHR* pFrameInfo + + + void vkCmdBeginVideoCodingKHR + VkCommandBuffer commandBuffer + const VkVideoBeginCodingInfoKHR* pBeginInfo + + + void vkCmdControlVideoCodingKHR + VkCommandBuffer commandBuffer + const VkVideoCodingControlInfoKHR* pCodingControlInfo + + + void vkCmdEndVideoCodingKHR + VkCommandBuffer commandBuffer + const VkVideoEndCodingInfoKHR* pEndCodingInfo + + + void vkCmdEncodeVideoKHR + VkCommandBuffer commandBuffer + const VkVideoEncodeInfoKHR* pEncodeInfo + + + VkResult vkCreateCuModuleNVX + VkDevice device + const VkCuModuleCreateInfoNVX* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkCuModuleNVX* pModule + + + VkResult vkCreateCuFunctionNVX + VkDevice device + const VkCuFunctionCreateInfoNVX* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkCuFunctionNVX* pFunction + + + void vkDestroyCuModuleNVX + VkDevice device + VkCuModuleNVX module + const VkAllocationCallbacks* pAllocator + + + void vkDestroyCuFunctionNVX + VkDevice device + VkCuFunctionNVX function + const VkAllocationCallbacks* pAllocator + + + void vkCmdCuLaunchKernelNVX + VkCommandBuffer commandBuffer + const VkCuLaunchInfoNVX* pLaunchInfo + + + void vkSetDeviceMemoryPriorityEXT + VkDevice device + VkDeviceMemory memory + float priority + + + VkResult vkAcquireDrmDisplayEXT + VkPhysicalDevice physicalDevice + int32_t drmFd + VkDisplayKHR display + + + VkResult vkGetDrmDisplayEXT + VkPhysicalDevice physicalDevice + int32_t drmFd + uint32_t connectorId + VkDisplayKHR* display + + + VkResult vkWaitForPresentKHR + VkDevice device + VkSwapchainKHR swapchain + uint64_t presentId + uint64_t timeout + + + VkResult vkCreateBufferCollectionFUCHSIA + VkDevice device + const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkBufferCollectionFUCHSIA* pCollection + + + VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA + VkDevice device + VkBufferCollectionFUCHSIA collection + const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo + + + VkResult vkSetBufferCollectionImageConstraintsFUCHSIA + VkDevice device + VkBufferCollectionFUCHSIA collection + const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo + + + void vkDestroyBufferCollectionFUCHSIA + VkDevice device + VkBufferCollectionFUCHSIA collection + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetBufferCollectionPropertiesFUCHSIA + VkDevice device + VkBufferCollectionFUCHSIA collection + VkBufferCollectionPropertiesFUCHSIA* pProperties + + + void vkCmdBeginRenderingKHR + VkCommandBuffer commandBuffer + const VkRenderingInfoKHR* pRenderingInfo + + + void vkCmdEndRenderingKHR + VkCommandBuffer commandBuffer + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + offset 1 reserved for the old VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX enum + offset 2 reserved for the old VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX enum + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Additional dependent types / tokens extending enumerants, not explicitly mentioned + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Additional dependent types / tokens extending enumerants, not explicitly mentioned + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This duplicates definitions in VK_KHR_device_group below + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + VK_ANDROID_native_buffer is used between the Android Vulkan loader and drivers to implement the WSI extensions. It is not exposed to applications and uses types that are not part of Android's stable public API, so it is left disabled to keep it out of the standard Vulkan headers. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This duplicates definitions in other extensions, below + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + enum offset=0 was mistakenly used for the 1.1 core enum + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES + (value=1000094000). Fortunately, no conflict resulted. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This extension requires buffer_device_address functionality. + VK_EXT_buffer_device_address is also acceptable, but since it is deprecated the KHR version is preferred. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + These enums are present only to inform downstream + consumers like KTX2. There is no actual Vulkan extension + corresponding to the enums. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/registry/vkconventions.py b/registry/vkconventions.py new file mode 100755 index 0000000..c62d824 --- /dev/null +++ b/registry/vkconventions.py @@ -0,0 +1,280 @@ +#!/usr/bin/python3 -i +# +# Copyright 2013-2021 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 + +# Working-group-specific style conventions, +# used in generation. + +import re +import os + +from conventions import ConventionsBase + + +# Modified from default implementation - see category_requires_validation() below +CATEGORIES_REQUIRING_VALIDATION = set(('handle', 'enum', 'bitmask')) + +# Tokenize into "words" for structure types, approximately per spec "Implicit Valid Usage" section 2.7.2 +# This first set is for things we recognize explicitly as words, +# as exceptions to the general regex. +# Ideally these would be listed in the spec as exceptions, as OpenXR does. +SPECIAL_WORDS = set(( + '16Bit', # VkPhysicalDevice16BitStorageFeatures + '8Bit', # VkPhysicalDevice8BitStorageFeaturesKHR + 'AABB', # VkGeometryAABBNV + 'ASTC', # VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT + 'D3D12', # VkD3D12FenceSubmitInfoKHR + 'Float16', # VkPhysicalDeviceShaderFloat16Int8FeaturesKHR + 'ImagePipe', # VkImagePipeSurfaceCreateInfoFUCHSIA + 'Int64', # VkPhysicalDeviceShaderAtomicInt64FeaturesKHR + 'Int8', # VkPhysicalDeviceShaderFloat16Int8FeaturesKHR + 'MacOS', # VkMacOSSurfaceCreateInfoMVK + 'RGBA10X6', # VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT + 'Uint8', # VkPhysicalDeviceIndexTypeUint8FeaturesEXT + 'Win32', # VkWin32SurfaceCreateInfoKHR +)) +# A regex to match any of the SPECIAL_WORDS +EXCEPTION_PATTERN = r'(?P{})'.format( + '|'.join('(%s)' % re.escape(w) for w in SPECIAL_WORDS)) +MAIN_RE = re.compile( + # the negative lookahead is to prevent the all-caps pattern from being too greedy. + r'({}|([0-9]+)|([A-Z][a-z]+)|([A-Z][A-Z]*(?![a-z])))'.format(EXCEPTION_PATTERN)) + + +class VulkanConventions(ConventionsBase): + @property + def null(self): + """Preferred spelling of NULL.""" + return '`NULL`' + + @property + def struct_macro(self): + """Get the appropriate format macro for a structure. + + Primarily affects generated valid usage statements. + """ + + return 'slink:' + + @property + def constFlagBits(self): + """Returns True if static const flag bits should be generated, False if an enumerated type should be generated.""" + return False + + @property + def structtype_member_name(self): + """Return name of the structure type member""" + return 'sType' + + @property + def nextpointer_member_name(self): + """Return name of the structure pointer chain member""" + return 'pNext' + + @property + def valid_pointer_prefix(self): + """Return prefix to pointers which must themselves be valid""" + return 'valid' + + def is_structure_type_member(self, paramtype, paramname): + """Determine if member type and name match the structure type member.""" + return paramtype == 'VkStructureType' and paramname == self.structtype_member_name + + def is_nextpointer_member(self, paramtype, paramname): + """Determine if member type and name match the next pointer chain member.""" + return paramtype == 'void' and paramname == self.nextpointer_member_name + + def generate_structure_type_from_name(self, structname): + """Generate a structure type name, like VK_STRUCTURE_TYPE_CREATE_INSTANCE_INFO""" + + structure_type_parts = [] + # Tokenize into "words" + for elem in MAIN_RE.findall(structname): + word = elem[0] + if word == 'Vk': + structure_type_parts.append('VK_STRUCTURE_TYPE') + else: + structure_type_parts.append(word.upper()) + name = '_'.join(structure_type_parts) + + # The simple-minded rules need modification for some structure names + subpats = [ + [ r'_H_(26[45])_', r'_H\1_' ], + [ r'_VULKAN_([0-9])([0-9])_', r'_VULKAN_\1_\2_' ], + [ r'_VULKAN_SC_([0-9])([0-9])_',r'_VULKAN_SC_\1_\2_' ], + [ r'_DIRECT_FB_', r'_DIRECTFB_' ], + ] + + for subpat in subpats: + name = re.sub(subpat[0], subpat[1], name) + return name + + @property + def warning_comment(self): + """Return warning comment to be placed in header of generated Asciidoctor files""" + return '// WARNING: DO NOT MODIFY! This file is automatically generated from the vk.xml registry' + + @property + def file_suffix(self): + """Return suffix of generated Asciidoctor files""" + return '.txt' + + def api_name(self, spectype='api'): + """Return API or specification name for citations in ref pages.ref + pages should link to for + + spectype is the spec this refpage is for: 'api' is the Vulkan API + Specification. Defaults to 'api'. If an unrecognized spectype is + given, returns None. + """ + if spectype == 'api' or spectype is None: + return 'Vulkan' + else: + return None + + @property + def api_prefix(self): + """Return API token prefix""" + return 'VK_' + + @property + def write_contacts(self): + """Return whether contact list should be written to extension appendices""" + return True + + @property + def write_refpage_include(self): + """Return whether refpage include should be written to extension appendices""" + return True + + @property + def member_used_for_unique_vuid(self): + """Return the member name used in the VUID-...-...-unique ID.""" + return self.structtype_member_name + + def is_externsync_command(self, protoname): + """Returns True if the protoname element is an API command requiring + external synchronization + """ + return protoname is not None and 'vkCmd' in protoname + + def is_api_name(self, name): + """Returns True if name is in the reserved API namespace. + For Vulkan, these are names with a case-insensitive 'vk' prefix, or + a 'PFN_vk' function pointer type prefix. + """ + return name[0:2].lower() == 'vk' or name[0:6] == 'PFN_vk' + + def specURL(self, spectype='api'): + """Return public registry URL which ref pages should link to for the + current all-extensions HTML specification, so xrefs in the + asciidoc source that are not to ref pages can link into it + instead. N.b. this may need to change on a per-refpage basis if + there are multiple documents involved. + """ + return 'https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html' + + @property + def xml_api_name(self): + """Return the name used in the default API XML registry for the default API""" + # Allow the API to be overridden by environment variable - default to 'vulkansc' if not set + VulkanAPI = os.getenv('VULKAN_API') + if VulkanAPI: + return VulkanAPI + return 'vulkansc' + + @property + def registry_path(self): + """Return relpath to the default API XML registry in this project.""" + return 'xml/vk.xml' + + @property + def specification_path(self): + """Return relpath to the Asciidoctor specification sources in this project.""" + return '{generated}/meta' + + @property + def special_use_section_anchor(self): + """Return asciidoctor anchor name in the API Specification of the + section describing extension special uses in detail.""" + return 'extendingvulkan-compatibility-specialuse' + + @property + def extra_refpage_headers(self): + """Return any extra text to add to refpage headers.""" + return 'include::{config}/attribs.txt[]' + + @property + def extension_index_prefixes(self): + """Return a list of extension prefixes used to group extension refpages.""" + return ['VK_KHR', 'VK_EXT', 'VK'] + + @property + def unified_flag_refpages(self): + """Return True if Flags/FlagBits refpages are unified, False if + they are separate. + """ + return False + + @property + def spec_reflow_path(self): + """Return the path to the spec source folder to reflow""" + return os.getcwd() + + @property + def spec_no_reflow_dirs(self): + """Return a set of directories not to automatically descend into + when reflowing spec text + """ + return ('scripts', 'style') + + @property + def zero(self): + return '`0`' + + def category_requires_validation(self, category): + """Return True if the given type 'category' always requires validation. + + Overridden because Vulkan does not require "valid" text for basetype + in the spec right now.""" + return category in CATEGORIES_REQUIRING_VALIDATION + + @property + def should_skip_checking_codes(self): + """Return True if more than the basic validation of return codes should + be skipped for a command. + + Vulkan mostly relies on the validation layers rather than API + builtin error checking, so these checks are not appropriate. + + For example, passing in a VkFormat parameter will not potentially + generate a VK_ERROR_FORMAT_NOT_SUPPORTED code.""" + + return True + + def extension_include_string(self, ext): + """Return format string for include:: line for an extension appendix + file. ext is an object with the following members: + - name - extension string string + - vendor - vendor portion of name + - barename - remainder of name""" + + return 'include::{{appendices}}/{name}{suffix}[]'.format( + name=ext.name, suffix=self.file_suffix) + + @property + def refpage_generated_include_path(self): + """Return path relative to the generated reference pages, to the + generated API include files.""" + return "{generated}" + + def valid_flag_bit(self, bitpos): + """Return True if bitpos is an allowed numeric bit position for + an API flag bit. + + Vulkan uses 32 bit Vk*Flags types, and assumes C compilers may + cause Vk*FlagBits values with bit 31 set to result in a 64 bit + enumerated type, so disallows such flags.""" + return bitpos >= 0 and bitpos < 31 -- cgit v1.2.3